[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsRefl α r
c : Cardinal.{u_1}
⊢ c ≤ cof r ↔ ∀ {S : Set α}, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) → c ≤ #↑S
[PROOFSTEP]
rw [cof, le_csInf_iff'' (cof_nonempty r)]
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsRefl α r
c : Cardinal.{u_1}
⊢ (∀ (b : Cardinal.{u_1}), b ∈ {c | ∃ S, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) ∧ #↑S = c} → c ≤ b) ↔
    ∀ {S : Set α}, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) → c ≤ #↑S
[PROOFSTEP]
use fun H S h => H _ ⟨S, h, rfl⟩
[GOAL]
case mpr
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsRefl α r
c : Cardinal.{u_1}
⊢ (∀ {S : Set α}, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) → c ≤ #↑S) →
    ∀ (b : Cardinal.{u_1}), b ∈ {c | ∃ S, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) ∧ #↑S = c} → c ≤ b
[PROOFSTEP]
rintro H d ⟨S, h, rfl⟩
[GOAL]
case mpr.intro.intro
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsRefl α r
c : Cardinal.{u_1}
H : ∀ {S : Set α}, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) → c ≤ #↑S
S : Set α
h : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
⊢ c ≤ #↑S
[PROOFSTEP]
exact H h
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : IsRefl β s
f : r ≃r s
⊢ Cardinal.lift (cof r) ≤ Cardinal.lift (cof s)
[PROOFSTEP]
rw [Order.cof, Order.cof, lift_sInf, lift_sInf, le_csInf_iff'' (nonempty_image_iff.2 (Order.cof_nonempty s))]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : IsRefl β s
f : r ≃r s
⊢ ∀ (b : Cardinal.{max u v}),
    b ∈ Cardinal.lift '' {c | ∃ S, (∀ (a : β), ∃ b, b ∈ S ∧ s a b) ∧ #↑S = c} →
      sInf (Cardinal.lift '' {c | ∃ S, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) ∧ #↑S = c}) ≤ b
[PROOFSTEP]
rintro - ⟨-, ⟨u, H, rfl⟩, rfl⟩
[GOAL]
case intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : IsRefl β s
f : r ≃r s
u : Set β
H : ∀ (a : β), ∃ b, b ∈ u ∧ s a b
⊢ sInf (Cardinal.lift '' {c | ∃ S, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) ∧ #↑S = c}) ≤ Cardinal.lift #↑u
[PROOFSTEP]
apply csInf_le'
[GOAL]
case intro.intro.intro.intro.h
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : IsRefl β s
f : r ≃r s
u : Set β
H : ∀ (a : β), ∃ b, b ∈ u ∧ s a b
⊢ Cardinal.lift #↑u ∈ Cardinal.lift '' {c | ∃ S, (∀ (a : α), ∃ b, b ∈ S ∧ r a b) ∧ #↑S = c}
[PROOFSTEP]
refine' ⟨_, ⟨f.symm '' u, fun a => _, rfl⟩, lift_mk_eq.{u, v, max u v}.2 ⟨(f.symm.toEquiv.image u).symm⟩⟩
[GOAL]
case intro.intro.intro.intro.h
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : IsRefl β s
f : r ≃r s
u : Set β
H : ∀ (a : β), ∃ b, b ∈ u ∧ s a b
a : α
⊢ ∃ b, b ∈ ↑(RelIso.symm f) '' u ∧ r a b
[PROOFSTEP]
rcases H (f a) with ⟨b, hb, hb'⟩
[GOAL]
case intro.intro.intro.intro.h.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : IsRefl β s
f : r ≃r s
u : Set β
H : ∀ (a : β), ∃ b, b ∈ u ∧ s a b
a : α
b : β
hb : b ∈ u
hb' : s (↑f a) b
⊢ ∃ b, b ∈ ↑(RelIso.symm f) '' u ∧ r a b
[PROOFSTEP]
refine' ⟨f.symm b, mem_image_of_mem _ hb, f.map_rel_iff.1 _⟩
[GOAL]
case intro.intro.intro.intro.h.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : IsRefl β s
f : r ≃r s
u : Set β
H : ∀ (a : β), ∃ b, b ∈ u ∧ s a b
a : α
b : β
hb : b ∈ u
hb' : s (↑f a) b
⊢ s (↑f a) (↑f (↑(RelIso.symm f) b))
[PROOFSTEP]
rwa [RelIso.apply_symm_apply]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ ∀ (a b : WellOrder), a ≈ b → (fun a => StrictOrder.cof a.r) a = (fun a => StrictOrder.cof a.r) b
[PROOFSTEP]
rintro ⟨α, r, wo₁⟩ ⟨β, s, wo₂⟩ ⟨⟨f, hf⟩⟩
[GOAL]
case mk.mk.intro.mk
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
⊢ (fun a => StrictOrder.cof a.r) { α := α, r := r, wo := wo₁ } =
    (fun a => StrictOrder.cof a.r) { α := β, r := s, wo := wo₂ }
[PROOFSTEP]
haveI := wo₁
[GOAL]
case mk.mk.intro.mk
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this : IsWellOrder α r
⊢ (fun a => StrictOrder.cof a.r) { α := α, r := r, wo := wo₁ } =
    (fun a => StrictOrder.cof a.r) { α := β, r := s, wo := wo₂ }
[PROOFSTEP]
haveI := wo₂
[GOAL]
case mk.mk.intro.mk
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ (fun a => StrictOrder.cof a.r) { α := α, r := r, wo := wo₁ } =
    (fun a => StrictOrder.cof a.r) { α := β, r := s, wo := wo₂ }
[PROOFSTEP]
dsimp only
[GOAL]
case mk.mk.intro.mk
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ StrictOrder.cof r = StrictOrder.cof s
[PROOFSTEP]
apply @RelIso.cof_eq _ _ _ _ ?_ ?_
[GOAL]
case mk.mk.intro.mk
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ swap rᶜ ≃r swap sᶜ
[PROOFSTEP]
constructor
[GOAL]
case mk.mk.intro.mk.map_rel_iff'
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ ∀ {a b : α}, swap sᶜ (↑?mk.mk.intro.mk.toEquiv a) (↑?mk.mk.intro.mk.toEquiv b) ↔ swap rᶜ a b
case mk.mk.intro.mk.toEquiv
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ α ≃ β
[PROOFSTEP]
exact @fun a b => not_iff_not.2 hf
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ IsRefl α (swap rᶜ)
[PROOFSTEP]
dsimp only [swap]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ IsRefl α fun y x => rᶜ x y
[PROOFSTEP]
exact ⟨fun _ => irrefl _⟩
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ IsRefl β (swap sᶜ)
[PROOFSTEP]
dsimp only [swap]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo₁ : IsWellOrder α r
β : Type u
s : β → β → Prop
wo₂ : IsWellOrder β s
f : α ≃ β
hf : ∀ {a b : α}, s (↑f a) (↑f b) ↔ r a b
this✝ : IsWellOrder α r
this : IsWellOrder β s
⊢ IsRefl β fun y x => sᶜ x y
[PROOFSTEP]
exact ⟨fun _ => irrefl _⟩
[GOAL]
α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
c : Cardinal.{u_1}
⊢ (∀ (S : Set α), Unbounded r S → c ≤ #↑S) → ∀ (b : Cardinal.{u_1}), b ∈ {c | ∃ S, Unbounded r S ∧ #↑S = c} → c ≤ b
[PROOFSTEP]
rintro H d ⟨S, h, rfl⟩
[GOAL]
case intro.intro
α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
c : Cardinal.{u_1}
H : ∀ (S : Set α), Unbounded r S → c ≤ #↑S
S : Set α
h : Unbounded r S
⊢ c ≤ #↑S
[PROOFSTEP]
exact H _ h
[GOAL]
α : Type u_1
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
⊢ #↑S < cof (type r) → Bounded r S
[PROOFSTEP]
simpa using not_imp_not.2 cof_type_le
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ ∃ S, Unbounded r S ∧ type (Subrel r S) = ord (cof (type r))
[PROOFSTEP]
let ⟨S, hS, e⟩ := cof_eq r
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
⊢ ∃ S, Unbounded r S ∧ type (Subrel r S) = ord (cof (type r))
[PROOFSTEP]
let ⟨s, _, e'⟩ := Cardinal.ord_eq S
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
⊢ ∃ S, Unbounded r S ∧ type (Subrel r S) = ord (cof (type r))
[PROOFSTEP]
let T : Set α := {a | ∃ aS : a ∈ S, ∀ b : S, s b ⟨_, aS⟩ → r b a}
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
⊢ ∃ S, Unbounded r S ∧ type (Subrel r S) = ord (cof (type r))
[PROOFSTEP]
suffices : Unbounded r T
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
⊢ ∃ S, Unbounded r S ∧ type (Subrel r S) = ord (cof (type r))
[PROOFSTEP]
refine' ⟨T, this, le_antisymm _ (Cardinal.ord_le.2 <| cof_type_le this)⟩
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
⊢ type (Subrel r T) ≤ ord (cof (type r))
[PROOFSTEP]
rw [← e, e']
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
⊢ type (Subrel r T) ≤ type s
[PROOFSTEP]
refine'
  (RelEmbedding.ofMonotone
      (fun a : T =>
        (⟨a,
            let ⟨aS, _⟩ := a.2
            aS⟩ :
          S))
      fun a b h => _).ordinal_type_le
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
a b : ↑T
h : Subrel r T a b
⊢ s ((fun a => { val := ↑a, property := (_ : ↑a ∈ S) }) a) ((fun a => { val := ↑a, property := (_ : ↑a ∈ S) }) b)
[PROOFSTEP]
rcases a with ⟨a, aS, ha⟩
[GOAL]
case mk.intro
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
b : ↑T
a : α
aS : a ∈ S
ha : ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a
h : Subrel r T { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) } b
⊢ s
    ((fun a => { val := ↑a, property := (_ : ↑a ∈ S) })
      { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) })
    ((fun a => { val := ↑a, property := (_ : ↑a ∈ S) }) b)
[PROOFSTEP]
rcases b with ⟨b, bS, hb⟩
[GOAL]
case mk.intro.mk.intro
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
a : α
aS : a ∈ S
ha : ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a
b : α
bS : b ∈ S
hb : ∀ (b_1 : ↑S), s b_1 { val := b, property := bS } → r (↑b_1) b
h :
  Subrel r T { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) }
    { val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) }
⊢ s
    ((fun a => { val := ↑a, property := (_ : ↑a ∈ S) })
      { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) })
    ((fun a => { val := ↑a, property := (_ : ↑a ∈ S) })
      { val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) })
[PROOFSTEP]
change s ⟨a, _⟩ ⟨b, _⟩
[GOAL]
case mk.intro.mk.intro
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
a : α
aS : a ∈ S
ha : ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a
b : α
bS : b ∈ S
hb : ∀ (b_1 : ↑S), s b_1 { val := b, property := bS } → r (↑b_1) b
h :
  Subrel r T { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) }
    { val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) }
⊢ s
    { val := a,
      property :=
        (_ : ↑{ val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) } ∈ S) }
    { val := b,
      property :=
        (_ : ↑{ val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) } ∈ S) }
[PROOFSTEP]
refine' ((trichotomous_of s _ _).resolve_left fun hn => _).resolve_left _
[GOAL]
case mk.intro.mk.intro.refine'_1
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
a : α
aS : a ∈ S
ha : ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a
b : α
bS : b ∈ S
hb : ∀ (b_1 : ↑S), s b_1 { val := b, property := bS } → r (↑b_1) b
h :
  Subrel r T { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) }
    { val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) }
hn :
  s
    { val := b,
      property :=
        (_ : ↑{ val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) } ∈ S) }
    { val := a,
      property :=
        (_ : ↑{ val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) } ∈ S) }
⊢ False
[PROOFSTEP]
exact asymm h (ha _ hn)
[GOAL]
case mk.intro.mk.intro.refine'_2
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
a : α
aS : a ∈ S
ha : ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a
b : α
bS : b ∈ S
hb : ∀ (b_1 : ↑S), s b_1 { val := b, property := bS } → r (↑b_1) b
h :
  Subrel r T { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) }
    { val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) }
⊢ ¬{ val := b,
        property :=
          (_ :
            ↑{ val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) } ∈
              S) } =
      { val := a,
        property :=
          (_ : ↑{ val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) } ∈ S) }
[PROOFSTEP]
intro e
[GOAL]
case mk.intro.mk.intro.refine'_2
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e✝ : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
a : α
aS : a ∈ S
ha : ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a
b : α
bS : b ∈ S
hb : ∀ (b_1 : ↑S), s b_1 { val := b, property := bS } → r (↑b_1) b
h :
  Subrel r T { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) }
    { val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) }
e :
  { val := b,
      property :=
        (_ :
          ↑{ val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) } ∈ S) } =
    { val := a,
      property :=
        (_ : ↑{ val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) } ∈ S) }
⊢ False
[PROOFSTEP]
injection e with e
[GOAL]
case mk.intro.mk.intro.refine'_2
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e✝ : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
a : α
aS : a ∈ S
ha : ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a
b : α
bS : b ∈ S
hb : ∀ (b_1 : ↑S), s b_1 { val := b, property := bS } → r (↑b_1) b
h :
  Subrel r T { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) }
    { val := b, property := (_ : ∃ aS, ∀ (b_1 : ↑S), s b_1 { val := b, property := aS } → r (↑b_1) b) }
e : b = a
⊢ False
[PROOFSTEP]
subst b
[GOAL]
case mk.intro.mk.intro.refine'_2
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
this : Unbounded r T
a : α
aS : a ∈ S
ha : ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a
bS : a ∈ S
hb : ∀ (b : ↑S), s b { val := a, property := bS } → r (↑b) a
h :
  Subrel r T { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) }
    { val := a, property := (_ : ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a) }
⊢ False
[PROOFSTEP]
exact irrefl _ h
[GOAL]
case this
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
⊢ Unbounded r T
[PROOFSTEP]
intro a
[GOAL]
case this
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
⊢ ∃ b, b ∈ T ∧ ¬r b a
[PROOFSTEP]
have : {b : S | ¬r b a}.Nonempty :=
  let ⟨b, bS, ba⟩ := hS a
  ⟨⟨b, bS⟩, ba⟩
[GOAL]
case this
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
this : Set.Nonempty {b | ¬r (↑b) a}
⊢ ∃ b, b ∈ T ∧ ¬r b a
[PROOFSTEP]
let b := (IsWellFounded.wf : WellFounded s).min _ this
[GOAL]
case this
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
this : Set.Nonempty {b | ¬r (↑b) a}
b : ↑S := WellFounded.min (_ : WellFounded s) {b | ¬r (↑b) a} this
⊢ ∃ b, b ∈ T ∧ ¬r b a
[PROOFSTEP]
have ba : ¬r b a := IsWellFounded.wf.min_mem _ this
[GOAL]
case this
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
this : Set.Nonempty {b | ¬r (↑b) a}
b : ↑S := WellFounded.min (_ : WellFounded s) {b | ¬r (↑b) a} this
ba : ¬r (↑b) a
⊢ ∃ b, b ∈ T ∧ ¬r b a
[PROOFSTEP]
refine' ⟨b, ⟨b.2, fun c => not_imp_not.1 fun h => _⟩, ba⟩
[GOAL]
case this
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
this : Set.Nonempty {b | ¬r (↑b) a}
b : ↑S := WellFounded.min (_ : WellFounded s) {b | ¬r (↑b) a} this
ba : ¬r (↑b) a
c : ↑S
h : ¬r ↑c ↑b
⊢ ¬s c { val := ↑b, property := (_ : ↑b ∈ S) }
[PROOFSTEP]
rw [show ∀ b : S, (⟨b, b.2⟩ : S) = b by intro b; cases b; rfl]
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
this : Set.Nonempty {b | ¬r (↑b) a}
b : ↑S := WellFounded.min (_ : WellFounded s) {b | ¬r (↑b) a} this
ba : ¬r (↑b) a
c : ↑S
h : ¬r ↑c ↑b
⊢ ∀ (b : ↑S), { val := ↑b, property := (_ : ↑b ∈ S) } = b
[PROOFSTEP]
intro b
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
this : Set.Nonempty {b | ¬r (↑b) a}
b✝ : ↑S := WellFounded.min (_ : WellFounded s) {b | ¬r (↑b) a} this
ba : ¬r (↑b✝) a
c : ↑S
h : ¬r ↑c ↑b✝
b : ↑S
⊢ { val := ↑b, property := (_ : ↑b ∈ S) } = b
[PROOFSTEP]
cases b
[GOAL]
case mk
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
this : Set.Nonempty {b | ¬r (↑b) a}
b : ↑S := WellFounded.min (_ : WellFounded s) {b | ¬r (↑b) a} this
ba : ¬r (↑b) a
c : ↑S
h : ¬r ↑c ↑b
val✝ : α
property✝ : val✝ ∈ S
⊢ { val := ↑{ val := val✝, property := property✝ }, property := (_ : ↑{ val := val✝, property := property✝ } ∈ S) } =
    { val := val✝, property := property✝ }
[PROOFSTEP]
rfl
[GOAL]
case this
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
hS : Unbounded r S
e : #↑S = cof (type r)
s : ↑S → ↑S → Prop
w✝ : IsWellOrder (↑S) s
e' : ord #↑S = type s
T : Set α := {a | ∃ aS, ∀ (b : ↑S), s b { val := a, property := aS } → r (↑b) a}
a : α
this : Set.Nonempty {b | ¬r (↑b) a}
b : ↑S := WellFounded.min (_ : WellFounded s) {b | ¬r (↑b) a} this
ba : ¬r (↑b) a
c : ↑S
h : ¬r ↑c ↑b
⊢ ¬s c b
[PROOFSTEP]
exact IsWellFounded.wf.not_lt_min _ this (IsOrderConnected.neg_trans h ba)
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ cof o = sInf {a | ∃ ι f, lsub f = o ∧ #ι = a}
[PROOFSTEP]
refine' le_antisymm (le_csInf (cof_lsub_def_nonempty o) _) (csInf_le' _)
[GOAL]
case refine'_1
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ ∀ (b : Cardinal.{u}), b ∈ {a | ∃ ι f, lsub f = o ∧ #ι = a} → cof o ≤ b
[PROOFSTEP]
rintro a ⟨ι, f, hf, rfl⟩
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
⊢ cof o ≤ #ι
[PROOFSTEP]
rw [← type_lt o]
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
⊢ cof (type fun x x_1 => x < x_1) ≤ #ι
[PROOFSTEP]
refine'
  (cof_type_le fun a => _).trans
    (@mk_le_of_injective _ _
      (fun s : typein ((· < ·) : o.out.α → o.out.α → Prop) ⁻¹' Set.range f => Classical.choose s.prop) fun s t hst =>
      by
      let H := congr_arg f hst
      rwa [Classical.choose_spec s.prop, Classical.choose_spec t.prop, typein_inj, Subtype.coe_inj] at H )
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
s t : ↑((typein fun x x_1 => x < x_1) ⁻¹' range f)
hst :
  (fun s => choose (_ : ↑s ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f)) s =
    (fun s => choose (_ : ↑s ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f)) t
⊢ s = t
[PROOFSTEP]
let H := congr_arg f hst
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
s t : ↑((typein fun x x_1 => x < x_1) ⁻¹' range f)
hst :
  (fun s => choose (_ : ↑s ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f)) s =
    (fun s => choose (_ : ↑s ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f)) t
H : f ((fun s => choose (_ : ↑s ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f)) s) =
  f ((fun s => choose (_ : ↑s ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f)) t) :=
  congr_arg f hst
⊢ s = t
[PROOFSTEP]
rwa [Classical.choose_spec s.prop, Classical.choose_spec t.prop, typein_inj, Subtype.coe_inj] at H
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
⊢ ∃ b, b ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f ∧ ¬b < a
[PROOFSTEP]
have := typein_lt_self a
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
this : typein (fun x x_1 => x < x_1) a < o
⊢ ∃ b, b ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f ∧ ¬b < a
[PROOFSTEP]
simp_rw [← hf, lt_lsub_iff] at this
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
this : ∃ i, typein (fun x x_1 => x < x_1) a ≤ f i
⊢ ∃ b, b ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f ∧ ¬b < a
[PROOFSTEP]
cases' this with i hi
[GOAL]
case refine'_1.intro.intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
i : ι
hi : typein (fun x x_1 => x < x_1) a ≤ f i
⊢ ∃ b, b ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f ∧ ¬b < a
[PROOFSTEP]
refine' ⟨enum (· < ·) (f i) _, _, _⟩
[GOAL]
case refine'_1.intro.intro.intro.intro.refine'_1
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
i : ι
hi : typein (fun x x_1 => x < x_1) a ≤ f i
⊢ f i < type fun x x_1 => x < x_1
[PROOFSTEP]
rw [type_lt, ← hf]
[GOAL]
case refine'_1.intro.intro.intro.intro.refine'_1
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
i : ι
hi : typein (fun x x_1 => x < x_1) a ≤ f i
⊢ f i < lsub f
[PROOFSTEP]
apply lt_lsub
[GOAL]
case refine'_1.intro.intro.intro.intro.refine'_2
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
i : ι
hi : typein (fun x x_1 => x < x_1) a ≤ f i
⊢ enum (fun x x_1 => x < x_1) (f i) (_ : f i < type fun x x_1 => x < x_1) ∈ (typein fun x x_1 => x < x_1) ⁻¹' range f
[PROOFSTEP]
rw [mem_preimage, typein_enum]
[GOAL]
case refine'_1.intro.intro.intro.intro.refine'_2
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
i : ι
hi : typein (fun x x_1 => x < x_1) a ≤ f i
⊢ f i ∈ range f
[PROOFSTEP]
exact mem_range_self i
[GOAL]
case refine'_1.intro.intro.intro.intro.refine'_3
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
a : (Quotient.out o).α
i : ι
hi : typein (fun x x_1 => x < x_1) a ≤ f i
⊢ ¬enum (fun x x_1 => x < x_1) (f i) (_ : f i < type fun x x_1 => x < x_1) < a
[PROOFSTEP]
rwa [← typein_le_typein, typein_enum]
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ cof o ∈ {a | ∃ ι f, lsub f = o ∧ #ι = a}
[PROOFSTEP]
rcases cof_eq (· < · : (Quotient.out o).α → (Quotient.out o).α → Prop) with ⟨S, hS, hS'⟩
[GOAL]
case refine'_2.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
S : Set (Quotient.out o).α
hS : Unbounded (fun x x_1 => x < x_1) S
hS' : #↑S = cof (type fun x x_1 => x < x_1)
⊢ cof o ∈ {a | ∃ ι f, lsub f = o ∧ #ι = a}
[PROOFSTEP]
let f : S → Ordinal := fun s => typein LT.lt s.val
[GOAL]
case refine'_2.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
S : Set (Quotient.out o).α
hS : Unbounded (fun x x_1 => x < x_1) S
hS' : #↑S = cof (type fun x x_1 => x < x_1)
f : ↑S → Ordinal.{u} := fun s => typein LT.lt ↑s
⊢ cof o ∈ {a | ∃ ι f, lsub f = o ∧ #ι = a}
[PROOFSTEP]
refine'
  ⟨S, f, le_antisymm (lsub_le fun i => typein_lt_self i) (le_of_forall_lt fun a ha => _), by rwa [type_lt o] at hS' ⟩
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
S : Set (Quotient.out o).α
hS : Unbounded (fun x x_1 => x < x_1) S
hS' : #↑S = cof (type fun x x_1 => x < x_1)
f : ↑S → Ordinal.{u} := fun s => typein LT.lt ↑s
⊢ #↑S = cof o
[PROOFSTEP]
rwa [type_lt o] at hS'
[GOAL]
case refine'_2.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
S : Set (Quotient.out o).α
hS : Unbounded (fun x x_1 => x < x_1) S
hS' : #↑S = cof (type fun x x_1 => x < x_1)
f : ↑S → Ordinal.{u} := fun s => typein LT.lt ↑s
a : Ordinal.{u}
ha : a < o
⊢ a < lsub f
[PROOFSTEP]
rw [← type_lt o] at ha
[GOAL]
case refine'_2.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
S : Set (Quotient.out o).α
hS : Unbounded (fun x x_1 => x < x_1) S
hS' : #↑S = cof (type fun x x_1 => x < x_1)
f : ↑S → Ordinal.{u} := fun s => typein LT.lt ↑s
a : Ordinal.{u}
ha : a < type fun x x_1 => x < x_1
⊢ a < lsub f
[PROOFSTEP]
rcases hS (enum (· < ·) a ha) with ⟨b, hb, hb'⟩
[GOAL]
case refine'_2.intro.intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
S : Set (Quotient.out o).α
hS : Unbounded (fun x x_1 => x < x_1) S
hS' : #↑S = cof (type fun x x_1 => x < x_1)
f : ↑S → Ordinal.{u} := fun s => typein LT.lt ↑s
a : Ordinal.{u}
ha : a < type fun x x_1 => x < x_1
b : (Quotient.out o).α
hb : b ∈ S
hb' : ¬(fun x x_1 => x < x_1) b (enum (fun x x_1 => x < x_1) a ha)
⊢ a < lsub f
[PROOFSTEP]
rw [← typein_le_typein, typein_enum] at hb'
[GOAL]
case refine'_2.intro.intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
S : Set (Quotient.out o).α
hS : Unbounded (fun x x_1 => x < x_1) S
hS' : #↑S = cof (type fun x x_1 => x < x_1)
f : ↑S → Ordinal.{u} := fun s => typein LT.lt ↑s
a : Ordinal.{u}
ha : a < type fun x x_1 => x < x_1
b : (Quotient.out o).α
hb : b ∈ S
hb' : a ≤ typein LT.lt b
⊢ a < lsub f
[PROOFSTEP]
exact hb'.trans_lt (lt_lsub.{u, u} f ⟨b, hb⟩)
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{v}
⊢ Cardinal.lift (cof o) = cof (lift o)
[PROOFSTEP]
refine' inductionOn o _
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{v}
⊢ ∀ (α : Type v) (r : α → α → Prop) [inst : IsWellOrder α r], Cardinal.lift (cof (type r)) = cof (lift (type r))
[PROOFSTEP]
intro α r _
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ Cardinal.lift (cof (type r)) = cof (lift (type r))
[PROOFSTEP]
apply le_antisymm
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ Cardinal.lift (cof (type r)) ≤ cof (lift (type r))
[PROOFSTEP]
refine' le_cof_type.2 fun S H => _
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set (ULift { α := α, r := r, wo := inst✝ }.α)
H : Unbounded (ULift.down ⁻¹'o { α := α, r := r, wo := inst✝ }.r) S
⊢ Cardinal.lift (cof (type r)) ≤ #↑S
[PROOFSTEP]
have : Cardinal.lift.{u, v} #(ULift.up ⁻¹' S) ≤ #(S : Type (max u v)) :=
  by
  rw [← Cardinal.lift_umax.{v, u}, ← Cardinal.lift_id'.{v, u} #S]
  refine mk_preimage_of_injective_lift.{v, max u v} ULift.up S (ULift.up_injective.{u, v})
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set (ULift { α := α, r := r, wo := inst✝ }.α)
H : Unbounded (ULift.down ⁻¹'o { α := α, r := r, wo := inst✝ }.r) S
⊢ Cardinal.lift #↑(ULift.up ⁻¹' S) ≤ #↑S
[PROOFSTEP]
rw [← Cardinal.lift_umax.{v, u}, ← Cardinal.lift_id'.{v, u} #S]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set (ULift { α := α, r := r, wo := inst✝ }.α)
H : Unbounded (ULift.down ⁻¹'o { α := α, r := r, wo := inst✝ }.r) S
⊢ Cardinal.lift #↑(ULift.up ⁻¹' S) ≤ Cardinal.lift #↑S
[PROOFSTEP]
refine mk_preimage_of_injective_lift.{v, max u v} ULift.up S (ULift.up_injective.{u, v})
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set (ULift { α := α, r := r, wo := inst✝ }.α)
H : Unbounded (ULift.down ⁻¹'o { α := α, r := r, wo := inst✝ }.r) S
this : Cardinal.lift #↑(ULift.up ⁻¹' S) ≤ #↑S
⊢ Cardinal.lift (cof (type r)) ≤ #↑S
[PROOFSTEP]
refine' (Cardinal.lift_le.2 <| cof_type_le _).trans this
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set (ULift { α := α, r := r, wo := inst✝ }.α)
H : Unbounded (ULift.down ⁻¹'o { α := α, r := r, wo := inst✝ }.r) S
this : Cardinal.lift #↑(ULift.up ⁻¹' S) ≤ #↑S
⊢ Unbounded r (ULift.up ⁻¹' S)
[PROOFSTEP]
exact fun a =>
  let ⟨⟨b⟩, bs, br⟩ := H ⟨a⟩
  ⟨b, bs, br⟩
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ cof (lift (type r)) ≤ Cardinal.lift (cof (type r))
[PROOFSTEP]
rcases cof_eq r with ⟨S, H, e'⟩
[GOAL]
case a.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
H : Unbounded r S
e' : #↑S = cof (type r)
⊢ cof (lift (type r)) ≤ Cardinal.lift (cof (type r))
[PROOFSTEP]
have : #(ULift.down.{u, v} ⁻¹' S) ≤ Cardinal.lift.{u, v} #S :=
  ⟨⟨fun ⟨⟨x⟩, h⟩ => ⟨⟨x, h⟩⟩, fun ⟨⟨x⟩, h₁⟩ ⟨⟨y⟩, h₂⟩ e => by simp at e ; congr⟩⟩
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
H : Unbounded r S
e' : #↑S = cof (type r)
x✝¹ x✝ : ↑(ULift.down ⁻¹' S)
x : α
h₁ : { down := x } ∈ ULift.down ⁻¹' S
y : α
h₂ : { down := y } ∈ ULift.down ⁻¹' S
e :
  (fun x =>
        match x with
        | { val := { down := x }, property := h } => { down := { val := x, property := h } })
      { val := { down := x }, property := h₁ } =
    (fun x =>
        match x with
        | { val := { down := x }, property := h } => { down := { val := x, property := h } })
      { val := { down := y }, property := h₂ }
⊢ { val := { down := x }, property := h₁ } = { val := { down := y }, property := h₂ }
[PROOFSTEP]
simp at e
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
H : Unbounded r S
e' : #↑S = cof (type r)
x✝¹ x✝ : ↑(ULift.down ⁻¹' S)
x : α
h₁ : { down := x } ∈ ULift.down ⁻¹' S
y : α
h₂ : { down := y } ∈ ULift.down ⁻¹' S
e : x = y
⊢ { val := { down := x }, property := h₁ } = { val := { down := y }, property := h₂ }
[PROOFSTEP]
congr
[GOAL]
case a.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
H : Unbounded r S
e' : #↑S = cof (type r)
this : #↑(ULift.down ⁻¹' S) ≤ Cardinal.lift #↑S
⊢ cof (lift (type r)) ≤ Cardinal.lift (cof (type r))
[PROOFSTEP]
rw [e'] at this
[GOAL]
case a.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
H : Unbounded r S
e' : #↑S = cof (type r)
this : #↑(ULift.down ⁻¹' S) ≤ Cardinal.lift (cof (type r))
⊢ cof (lift (type r)) ≤ Cardinal.lift (cof (type r))
[PROOFSTEP]
refine' (cof_type_le _).trans this
[GOAL]
case a.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
S : Set α
H : Unbounded r S
e' : #↑S = cof (type r)
this : #↑(ULift.down ⁻¹' S) ≤ Cardinal.lift (cof (type r))
⊢ Unbounded (ULift.down ⁻¹'o { α := α, r := r, wo := inst✝ }.r) (ULift.down ⁻¹' S)
[PROOFSTEP]
exact fun ⟨a⟩ =>
  let ⟨b, bs, br⟩ := H a
  ⟨⟨b⟩, bs, br⟩
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ cof o ≤ card o
[PROOFSTEP]
rw [cof_eq_sInf_lsub]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ sInf {a | ∃ ι f, lsub f = o ∧ #ι = a} ≤ card o
[PROOFSTEP]
exact csInf_le' card_mem_cof
[GOAL]
α : Type u_1
r : α → α → Prop
c : Cardinal.{u_2}
⊢ cof (ord c) ≤ c
[PROOFSTEP]
simpa using cof_le_card c.ord
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ ∃ ι f, lsub f = o ∧ #ι = cof o
[PROOFSTEP]
rw [cof_eq_sInf_lsub]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ ∃ ι f, lsub f = o ∧ #ι = sInf {a | ∃ ι f, lsub f = o ∧ #ι = a}
[PROOFSTEP]
exact csInf_mem (cof_lsub_def_nonempty o)
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
⊢ cof (lsub f) ≤ #ι
[PROOFSTEP]
rw [cof_eq_sInf_lsub]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
⊢ sInf {a | ∃ ι_1 f_1, lsub f_1 = lsub f ∧ #ι_1 = a} ≤ #ι
[PROOFSTEP]
exact csInf_le' ⟨ι, f, rfl, rfl⟩
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ cof (lsub f) ≤ Cardinal.lift #ι
[PROOFSTEP]
rw [← mk_uLift.{u, v}]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ cof (lsub f) ≤ #(ULift ι)
[PROOFSTEP]
convert cof_lsub_le.{max u v} fun i : ULift.{v, u} ι => f i.down
[GOAL]
case h.e'_3.h.e'_1
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
⊢ lsub f = lsub fun i => f i.down
[PROOFSTEP]
exact
  lsub_eq_of_range_eq.{u, max u v, max u v}
    (Set.ext fun x => ⟨fun ⟨i, hi⟩ => ⟨ULift.up.{v, u} i, hi⟩, fun ⟨i, hi⟩ => ⟨_, hi⟩⟩)
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
a : Cardinal.{u}
⊢ a ≤ cof o ↔ ∀ {ι : Type u} (f : ι → Ordinal.{u}), lsub f = o → a ≤ #ι
[PROOFSTEP]
rw [cof_eq_sInf_lsub]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
a : Cardinal.{u}
⊢ a ≤ sInf {a | ∃ ι f, lsub f = o ∧ #ι = a} ↔ ∀ {ι : Type u} (f : ι → Ordinal.{u}), lsub f = o → a ≤ #ι
[PROOFSTEP]
exact
  (le_csInf_iff'' (cof_lsub_def_nonempty o)).trans
    ⟨fun H ι f hf => H _ ⟨ι, f, hf, rfl⟩, fun H b ⟨ι, f, hf, hb⟩ =>
      by
      rw [← hb]
      exact H _ hf⟩
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {ι : Type u} (f : ι → Ordinal.{u}), lsub f = o → a ≤ #ι
b : Cardinal.{u}
x✝ : b ∈ {a | ∃ ι f, lsub f = o ∧ #ι = a}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
hb : #ι = b
⊢ a ≤ b
[PROOFSTEP]
rw [← hb]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {ι : Type u} (f : ι → Ordinal.{u}), lsub f = o → a ≤ #ι
b : Cardinal.{u}
x✝ : b ∈ {a | ∃ ι f, lsub f = o ∧ #ι = a}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
hb : #ι = b
⊢ a ≤ #ι
[PROOFSTEP]
exact H _ hf
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
c : Ordinal.{max u v}
hι : Cardinal.lift #ι < cof c
hf : ∀ (i : ι), f i < c
h : lsub f = c
⊢ False
[PROOFSTEP]
subst h
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
hι : Cardinal.lift #ι < cof (lsub f)
hf : ∀ (i : ι), f i < lsub f
⊢ False
[PROOFSTEP]
exact (cof_lsub_le_lift.{u, v} f).not_lt hι
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
c : Ordinal.{u}
hι : #ι < cof c
⊢ Cardinal.lift #ι < cof c
[PROOFSTEP]
rwa [(#ι).lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ Cardinal.lift #ι
[PROOFSTEP]
rw [← sup_eq_lsub_iff_lt_sup.{u, v}] at H
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
H : (sup fun i => f i) = lsub fun i => f i
⊢ cof (sup f) ≤ Cardinal.lift #ι
[PROOFSTEP]
rw [H]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
H : (sup fun i => f i) = lsub fun i => f i
⊢ cof (lsub fun i => f i) ≤ Cardinal.lift #ι
[PROOFSTEP]
exact cof_lsub_le_lift f
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ #ι
[PROOFSTEP]
rw [← (#ι).lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ Cardinal.lift #ι
[PROOFSTEP]
exact cof_sup_le_lift H
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
c : Ordinal.{u}
hι : #ι < cof c
⊢ Cardinal.lift #ι < cof c
[PROOFSTEP]
rwa [(#ι).lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift #ι < cof (ord c)
hf : ∀ (i : ι), f i < c
⊢ iSup f < c
[PROOFSTEP]
rw [← ord_lt_ord, iSup_ord (Cardinal.bddAbove_range.{u, v} _)]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift #ι < cof (ord c)
hf : ∀ (i : ι), f i < c
⊢ ⨆ (i : ι), ord (f i) < ord c
[PROOFSTEP]
refine' sup_lt_ord_lift hι fun i => _
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift #ι < cof (ord c)
hf : ∀ (i : ι), f i < c
i : ι
⊢ ord (f i) < ord c
[PROOFSTEP]
rw [ord_lt_ord]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift #ι < cof (ord c)
hf : ∀ (i : ι), f i < c
i : ι
⊢ f i < c
[PROOFSTEP]
apply hf
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u_2
f : ι → Cardinal.{u_2}
c : Cardinal.{u_2}
hι : #ι < cof (ord c)
⊢ Cardinal.lift #ι < cof (ord c)
[PROOFSTEP]
rwa [(#ι).lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < cof c
hc' : Cardinal.lift #ι < cof c
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < c → f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ nfpFamily f a < c
[PROOFSTEP]
refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
[GOAL]
case refine'_1
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < cof c
hc' : Cardinal.lift #ι < cof c
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < c → f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ Cardinal.lift (max ℵ₀ #ι) < cof c
[PROOFSTEP]
rw [lift_max]
[GOAL]
case refine'_1
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < cof c
hc' : Cardinal.lift #ι < cof c
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < c → f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ max (Cardinal.lift ℵ₀) (Cardinal.lift #ι) < cof c
[PROOFSTEP]
apply max_lt _ hc'
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < cof c
hc' : Cardinal.lift #ι < cof c
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < c → f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ Cardinal.lift ℵ₀ < cof c
[PROOFSTEP]
rwa [Cardinal.lift_aleph0]
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < cof c
hc' : Cardinal.lift #ι < cof c
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < c → f i b < c
a : Ordinal.{max u v}
ha : a < c
l : List ι
⊢ List.foldr f a l < c
[PROOFSTEP]
induction' l with i l H
[GOAL]
case refine'_2.nil
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < cof c
hc' : Cardinal.lift #ι < cof c
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < c → f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ List.foldr f a [] < c
[PROOFSTEP]
exact ha
[GOAL]
case refine'_2.cons
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < cof c
hc' : Cardinal.lift #ι < cof c
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < c → f i b < c
a : Ordinal.{max u v}
ha : a < c
i : ι
l : List ι
H : List.foldr f a l < c
⊢ List.foldr f a (i :: l) < c
[PROOFSTEP]
exact hf _ _ H
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u} → Ordinal.{u}
c : Ordinal.{u}
hc : ℵ₀ < cof c
hc' : #ι < cof c
hf : ∀ (i : ι) (b : Ordinal.{u}), b < c → f i b < c
a : Ordinal.{u}
⊢ Cardinal.lift #ι < cof c
[PROOFSTEP]
rwa [(#ι).lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v} → Ordinal.{max u v}
c : Ordinal.{max u v}
hc : ℵ₀ < cof c
hc' : Cardinal.lift (card o) < cof c
hf : ∀ (i : Ordinal.{u}) (hi : i < o) (b : Ordinal.{max u v}), b < c → f i hi b < c
a : Ordinal.{max u v}
⊢ Cardinal.lift #(Quotient.out o).α < cof c
[PROOFSTEP]
rwa [mk_ordinal_out]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u} → Ordinal.{u}
c : Ordinal.{u}
hc : ℵ₀ < cof c
hc' : card o < cof c
hf : ∀ (i : Ordinal.{u}) (hi : i < o) (b : Ordinal.{u}), b < c → f i hi b < c
a : Ordinal.{u}
⊢ Cardinal.lift (card o) < cof c
[PROOFSTEP]
rwa [o.card.lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
c : Ordinal.{u_2}
hc : ℵ₀ < cof c
hf : ∀ (i : Ordinal.{u_2}), i < c → f i < c
a : Ordinal.{u_2}
⊢ Cardinal.lift #Unit < cof c
[PROOFSTEP]
simpa using Cardinal.one_lt_aleph0.trans hc
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ ∃ f, blsub (ord (cof o)) f = o
[PROOFSTEP]
rcases exists_lsub_cof o with ⟨ι, f, hf, hι⟩
[GOAL]
case intro.intro.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
hι : #ι = cof o
⊢ ∃ f, blsub (ord (cof o)) f = o
[PROOFSTEP]
rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
[GOAL]
case intro.intro.intro.intro.intro
α : Type u_1
r✝ : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = o
hι : #ι = cof o
r : ι → ι → Prop
hr : IsWellOrder ι r
hι' : ord #ι = type r
⊢ ∃ f, blsub (ord (cof o)) f = o
[PROOFSTEP]
rw [← @blsub_eq_lsub' ι r hr] at hf
[GOAL]
case intro.intro.intro.intro.intro
α : Type u_1
r✝ : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hι : #ι = cof o
r : ι → ι → Prop
hr : IsWellOrder ι r
hf : blsub (type r) (bfamilyOfFamily' r f) = o
hι' : ord #ι = type r
⊢ ∃ f, blsub (ord (cof o)) f = o
[PROOFSTEP]
rw [← hι, hι']
[GOAL]
case intro.intro.intro.intro.intro
α : Type u_1
r✝ : α → α → Prop
o : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hι : #ι = cof o
r : ι → ι → Prop
hr : IsWellOrder ι r
hf : blsub (type r) (bfamilyOfFamily' r f) = o
hι' : ord #ι = type r
⊢ ∃ f, blsub (type r) f = o
[PROOFSTEP]
exact ⟨_, hf⟩
[GOAL]
α : Type u_1
r : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {ι : Type u} (f : ι → Ordinal.{u}), lsub f = b → a ≤ #ι
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
hf : blsub o f = b
⊢ a ≤ card o
[PROOFSTEP]
simpa using H _ hf
[GOAL]
α : Type u_1
r : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), blsub o f = b → a ≤ card o
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = b
⊢ a ≤ #ι
[PROOFSTEP]
rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
[GOAL]
case intro.intro
α : Type u_1
r✝ : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), blsub o f = b → a ≤ card o
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = b
r : ι → ι → Prop
hr : IsWellOrder ι r
hι' : ord #ι = type r
⊢ a ≤ #ι
[PROOFSTEP]
rw [← @blsub_eq_lsub' ι r hr] at hf
[GOAL]
case intro.intro
α : Type u_1
r✝ : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), blsub o f = b → a ≤ card o
ι : Type u
f : ι → Ordinal.{u}
r : ι → ι → Prop
hr : IsWellOrder ι r
hf : blsub (type r) (bfamilyOfFamily' r f) = b
hι' : ord #ι = type r
⊢ a ≤ #ι
[PROOFSTEP]
simpa using H _ hf
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ cof (blsub o f) ≤ Cardinal.lift (card o)
[PROOFSTEP]
rw [← mk_ordinal_out o]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ cof (blsub o f) ≤ Cardinal.lift #(Quotient.out o).α
[PROOFSTEP]
exact cof_lsub_le_lift _
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ cof (blsub o f) ≤ card o
[PROOFSTEP]
rw [← o.card.lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ cof (blsub o f) ≤ Cardinal.lift (card o)
[PROOFSTEP]
exact cof_blsub_le_lift f
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
c : Ordinal.{max u v}
ho : Cardinal.lift (card o) < cof c
hf : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi < c
h : blsub o f = c
⊢ cof c ≤ Cardinal.lift (card o)
[PROOFSTEP]
simpa [← iSup_ord, hf, h] using cof_blsub_le_lift.{u, v} f
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
c : Ordinal.{u}
ho : card o < cof c
hf : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi < c
⊢ Cardinal.lift (card o) < cof c
[PROOFSTEP]
rwa [o.card.lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
H : ∀ (i : Ordinal.{u}) (h : i < o), f i h < bsup o f
⊢ cof (bsup o f) ≤ Cardinal.lift (card o)
[PROOFSTEP]
rw [← bsup_eq_blsub_iff_lt_bsup.{u, v}] at H
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
H : (bsup o fun i h => f i h) = blsub o fun i h => f i h
⊢ cof (bsup o f) ≤ Cardinal.lift (card o)
[PROOFSTEP]
rw [H]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
H : (bsup o fun i h => f i h) = blsub o fun i h => f i h
⊢ cof (blsub o fun i h => f i h) ≤ Cardinal.lift (card o)
[PROOFSTEP]
exact cof_blsub_le_lift.{u, v} f
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ (∀ (i : Ordinal.{u}) (h : i < o), f i h < bsup o f) → cof (bsup o f) ≤ card o
[PROOFSTEP]
rw [← o.card.lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ (∀ (i : Ordinal.{u}) (h : i < o), f i h < bsup o f) → cof (bsup o f) ≤ Cardinal.lift (card o)
[PROOFSTEP]
exact cof_bsup_le_lift
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
c : Ordinal.{u}
ho : card o < cof c
⊢ Cardinal.lift (card o) < cof c
[PROOFSTEP]
rwa [o.card.lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ cof 0 = 0
[PROOFSTEP]
refine LE.le.antisymm ?_ (Cardinal.zero_le _)
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ cof 0 ≤ 0
[PROOFSTEP]
rw [← card_zero]
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ cof 0 ≤ card 0
[PROOFSTEP]
exact cof_le_card 0
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
e : o = 0
⊢ cof o = 0
[PROOFSTEP]
simp [e]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ cof (succ o) = 1
[PROOFSTEP]
apply le_antisymm
[GOAL]
case a
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ cof (succ o) ≤ 1
[PROOFSTEP]
refine' inductionOn o fun α r _ => _
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
⊢ cof (succ (type r)) ≤ 1
[PROOFSTEP]
change cof (type _) ≤ _
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
⊢ cof (type (Sum.Lex r EmptyRelation)) ≤ 1
[PROOFSTEP]
rw [← (_ : #_ = 1)]
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
⊢ cof (type (Sum.Lex r EmptyRelation)) ≤ #?m.43749
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
⊢ Type u_2
α✝ : Type u_1 r✝ : α✝ → α✝ → Prop o : Ordinal.{u_2} α : Type u_2 r : α → α → Prop x✝ : IsWellOrder α r ⊢ #?m.43749 = 1
[PROOFSTEP]
apply cof_type_le
[GOAL]
case a.h
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
⊢ Unbounded (Sum.Lex r EmptyRelation) ?a.S✝
[PROOFSTEP]
refine' fun a => ⟨Sum.inr PUnit.unit, Set.mem_singleton _, _⟩
[GOAL]
case a.h
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
a : α ⊕ PUnit
⊢ ¬Sum.Lex r EmptyRelation (Sum.inr PUnit.unit) a
[PROOFSTEP]
rcases a with (a | ⟨⟨⟨⟩⟩⟩)
[GOAL]
case a.h.inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
a : α
⊢ ¬Sum.Lex r EmptyRelation (Sum.inr PUnit.unit) (Sum.inl a)
[PROOFSTEP]
simp [EmptyRelation]
[GOAL]
case a.h.inr.unit
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
⊢ ¬Sum.Lex r EmptyRelation (Sum.inr PUnit.unit) (Sum.inr PUnit.unit)
[PROOFSTEP]
simp [EmptyRelation]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
⊢ #↑{Sum.inr PUnit.unit} = 1
[PROOFSTEP]
rw [Cardinal.mk_fintype, Set.card_singleton]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u_2}
α : Type u_2
r : α → α → Prop
x✝ : IsWellOrder α r
⊢ ↑1 = 1
[PROOFSTEP]
simp
[GOAL]
case a
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ 1 ≤ cof (succ o)
[PROOFSTEP]
rw [← Cardinal.succ_zero, succ_le_iff]
[GOAL]
case a
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ 0 < cof (succ o)
[PROOFSTEP]
simpa [lt_iff_le_and_ne, Cardinal.zero_le] using fun h => succ_ne_zero o (cof_eq_zero.1 (Eq.symm h))
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
⊢ ∃ a, type r = succ a
[PROOFSTEP]
skip
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
⊢ ∃ a, type r = succ a
[PROOFSTEP]
rcases cof_eq r with ⟨S, hl, e⟩
[GOAL]
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = cof (type r)
⊢ ∃ a, type r = succ a
[PROOFSTEP]
rw [z] at e
[GOAL]
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
⊢ ∃ a, type r = succ a
[PROOFSTEP]
cases' mk_ne_zero_iff.1 (by rw [e]; exact one_ne_zero) with a
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
⊢ #?m.47546 ≠ 0
[PROOFSTEP]
rw [e]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
⊢ 1 ≠ 0
[PROOFSTEP]
exact one_ne_zero
[GOAL]
case intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
⊢ ∃ a, type r = succ a
[PROOFSTEP]
refine'
  ⟨typein r a, Eq.symm <| Quotient.sound ⟨RelIso.ofSurjective (RelEmbedding.ofMonotone _ fun x y => _) fun x => _⟩⟩
[GOAL]
case intro.intro.intro.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
⊢ ↑{b | r b ↑a} ⊕ PUnit → α
[PROOFSTEP]
apply Sum.rec <;> [exact Subtype.val; exact fun _ => a]
[GOAL]
case intro.intro.intro.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
⊢ ↑{b | r b ↑a} ⊕ PUnit → α
[PROOFSTEP]
apply Sum.rec
[GOAL]
case intro.intro.intro.refine'_1.inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
⊢ ↑{b | r b ↑a} → α
[PROOFSTEP]
exact Subtype.val
[GOAL]
case intro.intro.intro.refine'_1.inr
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
⊢ PUnit → α
[PROOFSTEP]
exact fun _ => a
[GOAL]
case intro.intro.intro.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x y : ↑{b | r b ↑a} ⊕ PUnit
⊢ Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation x y →
    r (Sum.rec Subtype.val (fun x => ↑a) x) (Sum.rec Subtype.val (fun x => ↑a) y)
[PROOFSTEP]
rcases x with (x | ⟨⟨⟨⟩⟩⟩)
[GOAL]
case intro.intro.intro.refine'_2.inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
y : ↑{b | r b ↑a} ⊕ PUnit
x : ↑{b | r b ↑a}
⊢ Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation (Sum.inl x) y →
    r (Sum.rec Subtype.val (fun x => ↑a) (Sum.inl x)) (Sum.rec Subtype.val (fun x => ↑a) y)
[PROOFSTEP]
rcases y with (y | ⟨⟨⟨⟩⟩⟩)
[GOAL]
case intro.intro.intro.refine'_2.inr.unit
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
y : ↑{b | r b ↑a} ⊕ PUnit
⊢ Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation (Sum.inr PUnit.unit) y →
    r (Sum.rec Subtype.val (fun x => ↑a) (Sum.inr PUnit.unit)) (Sum.rec Subtype.val (fun x => ↑a) y)
[PROOFSTEP]
rcases y with (y | ⟨⟨⟨⟩⟩⟩)
[GOAL]
case intro.intro.intro.refine'_2.inl.inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x y : ↑{b | r b ↑a}
⊢ Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation (Sum.inl x) (Sum.inl y) →
    r (Sum.rec Subtype.val (fun x => ↑a) (Sum.inl x)) (Sum.rec Subtype.val (fun x => ↑a) (Sum.inl y))
[PROOFSTEP]
simp [Subrel, Order.Preimage, EmptyRelation]
[GOAL]
case intro.intro.intro.refine'_2.inl.inr.unit
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : ↑{b | r b ↑a}
⊢ Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation (Sum.inl x) (Sum.inr PUnit.unit) →
    r (Sum.rec Subtype.val (fun x => ↑a) (Sum.inl x)) (Sum.rec Subtype.val (fun x => ↑a) (Sum.inr PUnit.unit))
[PROOFSTEP]
simp [Subrel, Order.Preimage, EmptyRelation]
[GOAL]
case intro.intro.intro.refine'_2.inr.unit.inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
y : ↑{b | r b ↑a}
⊢ Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation (Sum.inr PUnit.unit) (Sum.inl y) →
    r (Sum.rec Subtype.val (fun x => ↑a) (Sum.inr PUnit.unit)) (Sum.rec Subtype.val (fun x => ↑a) (Sum.inl y))
[PROOFSTEP]
simp [Subrel, Order.Preimage, EmptyRelation]
[GOAL]
case intro.intro.intro.refine'_2.inr.unit.inr.unit
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
⊢ Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation (Sum.inr PUnit.unit) (Sum.inr PUnit.unit) →
    r (Sum.rec Subtype.val (fun x => ↑a) (Sum.inr PUnit.unit)) (Sum.rec Subtype.val (fun x => ↑a) (Sum.inr PUnit.unit))
[PROOFSTEP]
simp [Subrel, Order.Preimage, EmptyRelation]
[GOAL]
case intro.intro.intro.refine'_2.inl.inr.unit
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : ↑{b | r b ↑a}
⊢ r ↑x ↑a
[PROOFSTEP]
exact x.2
[GOAL]
case intro.intro.intro.refine'_3
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
⊢ ∃ a_1,
    ↑(RelEmbedding.ofMonotone (Sum.rec Subtype.val fun x => ↑a)
            (_ :
              ∀ (x y : ↑{b | r b ↑a} ⊕ PUnit),
                Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation x y →
                  r (Sum.rec Subtype.val (fun x => ↑a) x) (Sum.rec Subtype.val (fun x => ↑a) y)))
        a_1 =
      x
[PROOFSTEP]
suffices : r x a ∨ ∃ _ : PUnit.{u}, ↑a = x
[GOAL]
case intro.intro.intro.refine'_3
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
this : r x ↑a ∨ ∃ x_1, ↑a = x
⊢ ∃ a_1,
    ↑(RelEmbedding.ofMonotone (Sum.rec Subtype.val fun x => ↑a)
            (_ :
              ∀ (x y : ↑{b | r b ↑a} ⊕ PUnit),
                Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation x y →
                  r (Sum.rec Subtype.val (fun x => ↑a) x) (Sum.rec Subtype.val (fun x => ↑a) y)))
        a_1 =
      x
[PROOFSTEP]
convert this
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
this : r x ↑a ∨ ∃ x_1, ↑a = x
⊢ (∃ a_1,
      ↑(RelEmbedding.ofMonotone (Sum.rec Subtype.val fun x => ↑a)
              (_ :
                ∀ (x y : ↑{b | r b ↑a} ⊕ PUnit),
                  Sum.Lex (Subrel r {b | r b ↑a}) EmptyRelation x y →
                    r (Sum.rec Subtype.val (fun x => ↑a) x) (Sum.rec Subtype.val (fun x => ↑a) y)))
          a_1 =
        x) ↔
    r x ↑a ∨ ∃ x_1, ↑a = x
[PROOFSTEP]
dsimp [RelEmbedding.ofMonotone]
[GOAL]
case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
this : r x ↑a ∨ ∃ x_1, ↑a = x
⊢ (∃ a_1, Sum.rec Subtype.val (fun x => ↑a) a_1 = x) ↔ r x ↑a ∨ ∃ x_1, ↑a = x
[PROOFSTEP]
simp
[GOAL]
case this
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
⊢ r x ↑a ∨ ∃ x_1, ↑a = x
[PROOFSTEP]
rcases trichotomous_of r x a with (h | h | h)
[GOAL]
case this.inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
h : r x ↑a
⊢ r x ↑a ∨ ∃ x_1, ↑a = x
[PROOFSTEP]
exact Or.inl h
[GOAL]
case this.inr.inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
h : x = ↑a
⊢ r x ↑a ∨ ∃ x_1, ↑a = x
[PROOFSTEP]
exact Or.inr ⟨PUnit.unit, h.symm⟩
[GOAL]
case this.inr.inr
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
h : r (↑a) x
⊢ r x ↑a ∨ ∃ x_1, ↑a = x
[PROOFSTEP]
rcases hl x with ⟨a', aS, hn⟩
[GOAL]
case this.inr.inr.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
h : r (↑a) x
a' : α
aS : a' ∈ S
hn : ¬r a' x
⊢ r x ↑a ∨ ∃ x_1, ↑a = x
[PROOFSTEP]
rw [(_ : ↑a = a')] at h
[GOAL]
case this.inr.inr.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x a' : α
h : r a' x
aS : a' ∈ S
hn : ¬r a' x
⊢ r x ↑a ∨ ∃ x_1, ↑a = x
[PROOFSTEP]
exact absurd h hn
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
h : r (↑a) x
a' : α
aS : a' ∈ S
hn : ¬r a' x
⊢ ↑a = a'
[PROOFSTEP]
refine' congr_arg Subtype.val (_ : a = ⟨a', aS⟩)
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
h : r (↑a) x
a' : α
aS : a' ∈ S
hn : ¬r a' x
⊢ a = { val := a', property := aS }
[PROOFSTEP]
haveI := le_one_iff_subsingleton.1 (le_of_eq e)
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
x✝ : IsWellOrder α r
z : cof (type r) = 1
S : Set α
hl : Unbounded r S
e : #↑S = 1
a : ↑S
x : α
h : r (↑a) x
a' : α
aS : a' ∈ S
hn : ¬r a' x
this : Subsingleton ↑S
⊢ a = { val := a', property := aS }
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
x✝ : ∃ a, o = succ a
a : Ordinal.{u}
e : o = succ a
⊢ cof o = 1
[PROOFSTEP]
simp [e]
[GOAL]
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
⊢ ord (cof a) ≤ o
[PROOFSTEP]
rw [← hf.2.2]
[GOAL]
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
⊢ ord (cof (blsub o f)) ≤ o
[PROOFSTEP]
exact (ord_le_ord.2 (cof_blsub_le f)).trans (ord_card_le o)
[GOAL]
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
i : Ordinal.{u}
hi : i < ord (cof a)
⊢ ord (cof a) ≤ o
[PROOFSTEP]
rw [hf.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
⊢ IsFundamentalSequence a (ord (cof a)) fun i hi => f i (_ : i < o)
[PROOFSTEP]
have H := hf.cof_eq
[GOAL]
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
H : ord (cof a) = o
⊢ IsFundamentalSequence a (ord (cof a)) fun i hi => f i (_ : i < o)
[PROOFSTEP]
subst H
[GOAL]
α : Type u_1
r : α → α → Prop
a : Ordinal.{u}
f : (b : Ordinal.{u}) → b < ord (cof a) → Ordinal.{u}
hf : IsFundamentalSequence a (ord (cof a)) f
⊢ IsFundamentalSequence a (ord (cof a)) fun i hi => f i (_ : i < ord (cof a))
[PROOFSTEP]
exact hf
[GOAL]
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o → Ordinal.{u}
f : (b : Ordinal.{u_2}) → b < 0 → Ordinal.{u_2}
⊢ 0 ≤ ord (cof 0)
[PROOFSTEP]
rw [cof_zero, ord_zero]
[GOAL]
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
⊢ IsFundamentalSequence (succ o) 1 fun x x => o
[PROOFSTEP]
refine' ⟨_, @fun i j hi hj h => _, blsub_const Ordinal.one_ne_zero o⟩
[GOAL]
case refine'_1
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
⊢ 1 ≤ ord (cof (succ o))
[PROOFSTEP]
rw [cof_succ, ord_one]
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
i j : Ordinal.{u}
hi : i < 1
hj : j < 1
h : i < j
⊢ (fun x x => o) i hi < (fun x x => o) j hj
[PROOFSTEP]
rw [lt_one_iff_zero] at hi hj
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
i j : Ordinal.{u}
hi✝ : i < 1
hi : i = 0
hj✝ : j < 1
hj : j = 0
h : i < j
⊢ (fun x x => o) i hi✝ < (fun x x => o) j hj✝
[PROOFSTEP]
rw [hi, hj] at h
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
i j : Ordinal.{u}
hi✝ : i < 1
hi : i = 0
hj✝ : j < 1
hj : j = 0
h : 0 < 0
⊢ (fun x x => o) i hi✝ < (fun x x => o) j hj✝
[PROOFSTEP]
exact h.false.elim
[GOAL]
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
i j : Ordinal.{u}
hi : i < o
hj : j < o
hij : i ≤ j
⊢ f i hi ≤ f j hj
[PROOFSTEP]
rcases lt_or_eq_of_le hij with (hij | rfl)
[GOAL]
case inl
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
i j : Ordinal.{u}
hi : i < o
hj : j < o
hij✝ : i ≤ j
hij : i < j
⊢ f i hi ≤ f j hj
[PROOFSTEP]
exact (hf.2.1 hi hj hij).le
[GOAL]
case inr
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
i : Ordinal.{u}
hi hj : i < o
hij : i ≤ i
⊢ f i hi ≤ f i hj
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
i : Ordinal.{u}
hi : i < o'
⊢ g i hi < o
[PROOFSTEP]
rw [← hg.2.2]
[GOAL]
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
i : Ordinal.{u}
hi : i < o'
⊢ g i hi < blsub o' g
[PROOFSTEP]
apply lt_blsub
[GOAL]
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
⊢ IsFundamentalSequence a o' fun i hi => f (g i hi) (_ : g i hi < o)
[PROOFSTEP]
refine' ⟨_, @fun i j _ _ h => hf.2.1 _ _ (hg.2.1 _ _ h), _⟩
[GOAL]
case refine'_1
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
⊢ o' ≤ ord (cof a)
[PROOFSTEP]
rw [hf.cof_eq]
[GOAL]
case refine'_1
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
⊢ o' ≤ o
[PROOFSTEP]
exact hg.1.trans (ord_cof_le o)
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
⊢ (blsub o' fun i hi => f (g i hi) (_ : g i hi < o)) = a
[PROOFSTEP]
rw [@blsub_comp.{u, u, u} o _ f (@IsFundamentalSequence.monotone _ _ f hf)]
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
⊢ blsub o f = a
case refine'_2.hg
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
⊢ (blsub o' fun i hi => g i hi) = o
[PROOFSTEP]
exact hf.2.2
[GOAL]
case refine'_2.hg
α : Type u_1
r : α → α → Prop
a✝ o✝ : Ordinal.{u}
f✝ : (b : Ordinal.{u}) → b < o✝ → Ordinal.{u}
a o o' : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
g : (b : Ordinal.{u}) → b < o' → Ordinal.{u}
hg : IsFundamentalSequence o o' g
⊢ (blsub o' fun i hi => g i hi) = o
[PROOFSTEP]
exact hg.2.2
[GOAL]
α : Type u_1
r : α → α → Prop
a : Ordinal.{u}
⊢ ∃ f, IsFundamentalSequence a (ord (cof a)) f
[PROOFSTEP]
suffices h : ∃ o f, IsFundamentalSequence a o f
[GOAL]
α : Type u_1
r : α → α → Prop
a : Ordinal.{u}
h : ∃ o f, IsFundamentalSequence a o f
⊢ ∃ f, IsFundamentalSequence a (ord (cof a)) f
[PROOFSTEP]
rcases h with ⟨o, f, hf⟩
[GOAL]
case intro.intro
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : IsFundamentalSequence a o f
⊢ ∃ f, IsFundamentalSequence a (ord (cof a)) f
[PROOFSTEP]
exact ⟨_, hf.ord_cof⟩
[GOAL]
case h
α : Type u_1
r : α → α → Prop
a : Ordinal.{u}
⊢ ∃ o f, IsFundamentalSequence a o f
[PROOFSTEP]
rcases exists_lsub_cof a with ⟨ι, f, hf, hι⟩
[GOAL]
case h.intro.intro.intro
α : Type u_1
r : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
⊢ ∃ o f, IsFundamentalSequence a o f
[PROOFSTEP]
rcases ord_eq ι with ⟨r, wo, hr⟩
[GOAL]
case h.intro.intro.intro.intro.intro
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
⊢ ∃ o f, IsFundamentalSequence a o f
[PROOFSTEP]
haveI := wo
[GOAL]
case h.intro.intro.intro.intro.intro
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this : IsWellOrder ι r
⊢ ∃ o f, IsFundamentalSequence a o f
[PROOFSTEP]
let r' := Subrel r {i | ∀ j, r j i → f j < f i}
[GOAL]
case h.intro.intro.intro.intro.intro
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
⊢ ∃ o f, IsFundamentalSequence a o f
[PROOFSTEP]
let hrr' : r' ↪r r := Subrel.relEmbedding _ _
[GOAL]
case h.intro.intro.intro.intro.intro
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
⊢ ∃ o f, IsFundamentalSequence a o f
[PROOFSTEP]
haveI := hrr'.isWellOrder
[GOAL]
case h.intro.intro.intro.intro.intro
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
⊢ ∃ o f, IsFundamentalSequence a o f
[PROOFSTEP]
refine'
  ⟨_, _, hrr'.ordinal_type_le.trans _, @fun i j _ h _ => (enum r' j h).prop _ _,
    le_antisymm (blsub_le fun i hi => lsub_le_iff.1 hf.le _) _⟩
[GOAL]
case h.intro.intro.intro.intro.intro.refine'_1
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
⊢ type r ≤ ord (cof a)
[PROOFSTEP]
rw [← hι, hr]
[GOAL]
case h.intro.intro.intro.intro.intro.refine'_2
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i j : Ordinal.{u}
x✝¹ : i < type r'
h : j < type r'
x✝ : i < j
⊢ r ↑(enum r' i x✝¹) ↑(enum r' j h)
[PROOFSTEP]
change r (hrr'.1 _) (hrr'.1 _)
[GOAL]
case h.intro.intro.intro.intro.intro.refine'_2
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i j : Ordinal.{u}
x✝¹ : i < type r'
h : j < type r'
x✝ : i < j
⊢ r (↑hrr'.toEmbedding (enum r' i x✝¹)) (↑hrr'.toEmbedding (enum r' j h))
[PROOFSTEP]
rwa [hrr'.2, @enum_lt_enum _ r']
[GOAL]
case h.intro.intro.intro.intro.intro.refine'_3
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
⊢ a ≤ blsub (type r') fun j h => f ↑(enum r' j h)
[PROOFSTEP]
rw [← hf, lsub_le_iff]
[GOAL]
case h.intro.intro.intro.intro.intro.refine'_3
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
⊢ ∀ (i : ι), f i < blsub (type r') fun j h => f ↑(enum r' j h)
[PROOFSTEP]
intro i
[GOAL]
case h.intro.intro.intro.intro.intro.refine'_3
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
⊢ f i < blsub (type r') fun j h => f ↑(enum r' j h)
[PROOFSTEP]
suffices h : ∃ i' hi', f i ≤ bfamilyOfFamily' r' (fun i => f i) i' hi'
[GOAL]
case h.intro.intro.intro.intro.intro.refine'_3
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ∃ i' hi', f i ≤ bfamilyOfFamily' r' (fun i => f ↑i) i' hi'
⊢ f i < blsub (type r') fun j h => f ↑(enum r' j h)
[PROOFSTEP]
rcases h with ⟨i', hi', hfg⟩
[GOAL]
case h.intro.intro.intro.intro.intro.refine'_3.intro.intro
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
i' : Ordinal.{u}
hi' : i' < type r'
hfg : f i ≤ bfamilyOfFamily' r' (fun i => f ↑i) i' hi'
⊢ f i < blsub (type r') fun j h => f ↑(enum r' j h)
[PROOFSTEP]
exact hfg.trans_lt (lt_blsub _ _ _)
[GOAL]
case h
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
⊢ ∃ i' hi', f i ≤ bfamilyOfFamily' r' (fun i => f ↑i) i' hi'
[PROOFSTEP]
by_cases h : ∀ j, r j i → f j < f i
[GOAL]
case pos
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ∀ (j : ι), r j i → f j < f i
⊢ ∃ i' hi', f i ≤ bfamilyOfFamily' r' (fun i => f ↑i) i' hi'
[PROOFSTEP]
refine' ⟨typein r' ⟨i, h⟩, typein_lt_type _ _, _⟩
[GOAL]
case pos
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ∀ (j : ι), r j i → f j < f i
⊢ f i ≤
    bfamilyOfFamily' r' (fun i => f ↑i) (typein r' { val := i, property := h })
      (_ : typein r' { val := i, property := h } < type r')
[PROOFSTEP]
rw [bfamilyOfFamily'_typein]
[GOAL]
case neg
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ¬∀ (j : ι), r j i → f j < f i
⊢ ∃ i' hi', f i ≤ bfamilyOfFamily' r' (fun i => f ↑i) i' hi'
[PROOFSTEP]
push_neg at h
[GOAL]
case neg
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ∃ j, r j i ∧ f i ≤ f j
⊢ ∃ i' hi', f i ≤ bfamilyOfFamily' r' (fun i => f ↑i) i' hi'
[PROOFSTEP]
cases' wo.wf.min_mem _ h with hji hij
[GOAL]
case neg.intro
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ∃ j, r j i ∧ f i ≤ f j
hji : r (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h) i
hij : f i ≤ f (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h)
⊢ ∃ i' hi', f i ≤ bfamilyOfFamily' r' (fun i => f ↑i) i' hi'
[PROOFSTEP]
refine' ⟨typein r' ⟨_, fun k hkj => lt_of_lt_of_le _ hij⟩, typein_lt_type _ _, _⟩
[GOAL]
case neg.intro.refine'_1
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ∃ j, r j i ∧ f i ≤ f j
hji : r (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h) i
hij : f i ≤ f (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h)
k : ι
hkj : r k (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h)
⊢ f k < f i
[PROOFSTEP]
by_contra' H
[GOAL]
case neg.intro.refine'_1
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ∃ j, r j i ∧ f i ≤ f j
hji : r (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h) i
hij : f i ≤ f (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h)
k : ι
hkj : r k (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h)
H : f i ≤ f k
⊢ False
[PROOFSTEP]
exact (wo.wf.not_lt_min _ h ⟨IsTrans.trans _ _ _ hkj hji, H⟩) hkj
[GOAL]
case neg.intro.refine'_2
α : Type u_1
r✝ : α → α → Prop
a : Ordinal.{u}
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = a
hι : #ι = cof a
r : ι → ι → Prop
wo : IsWellOrder ι r
hr : ord #ι = type r
this✝ : IsWellOrder ι r
r' : ↑{i | ∀ (j : ι), r j i → f j < f i} → ↑{i | ∀ (j : ι), r j i → f j < f i} → Prop :=
  Subrel r {i | ∀ (j : ι), r j i → f j < f i}
hrr' : r' ↪r r := Subrel.relEmbedding r {i | ∀ (j : ι), r j i → f j < f i}
this : IsWellOrder (↑{i | ∀ (j : ι), r j i → f j < f i}) r'
i : ι
h : ∃ j, r j i ∧ f i ≤ f j
hji : r (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h) i
hij : f i ≤ f (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h)
⊢ f i ≤
    bfamilyOfFamily' r' (fun i => f ↑i)
      (typein r'
        { val := WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h,
          property :=
            (_ :
              ∀ (k : ι),
                r k (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h) →
                  f k < f (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h)) })
      (_ :
        typein r'
            { val := WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h,
              property :=
                (_ :
                  ∀ (k : ι),
                    r k (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h) →
                      f k < f (WellFounded.min (_ : WellFounded r) (fun x => r x i ∧ f i ≤ f x) h)) } <
          type r')
[PROOFSTEP]
rwa [bfamilyOfFamily'_typein]
[GOAL]
α : Type u_1
r : α → α → Prop
a : Ordinal.{u}
⊢ cof (ord (cof a)) = cof a
[PROOFSTEP]
cases' exists_fundamental_sequence a with f hf
[GOAL]
case intro
α : Type u_1
r : α → α → Prop
a : Ordinal.{u}
f : (b : Ordinal.{u}) → b < ord (cof a) → Ordinal.{u}
hf : IsFundamentalSequence a (ord (cof a)) f
⊢ cof (ord (cof a)) = cof a
[PROOFSTEP]
cases' exists_fundamental_sequence a.cof.ord with g hg
[GOAL]
case intro.intro
α : Type u_1
r : α → α → Prop
a : Ordinal.{u}
f : (b : Ordinal.{u}) → b < ord (cof a) → Ordinal.{u}
hf : IsFundamentalSequence a (ord (cof a)) f
g : (b : Ordinal.{u}) → b < ord (cof (ord (cof a))) → Ordinal.{u}
hg : IsFundamentalSequence (ord (cof a)) (ord (cof (ord (cof a)))) g
⊢ cof (ord (cof a)) = cof a
[PROOFSTEP]
exact ord_injective (hf.trans hg).cof_eq.symm
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
⊢ IsFundamentalSequence (f a) o fun b hb => f (g b hb)
[PROOFSTEP]
refine' ⟨_, @fun i j _ _ h => hf.strictMono (hg.2.1 _ _ h), _⟩
[GOAL]
case refine'_1
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
⊢ o ≤ ord (cof (f a))
[PROOFSTEP]
rcases exists_lsub_cof (f a) with ⟨ι, f', hf', hι⟩
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
⊢ o ≤ ord (cof (f a))
[PROOFSTEP]
rw [← hg.cof_eq, ord_le_ord, ← hι]
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
⊢ cof a ≤ #ι
[PROOFSTEP]
suffices (lsub.{u, u} fun i => sInf {b : Ordinal | f' i ≤ f b}) = a
  by
  rw [← this]
  apply cof_lsub_le
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
this : (lsub fun i => sInf {b | f' i ≤ f b}) = a
⊢ cof a ≤ #ι
[PROOFSTEP]
rw [← this]
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
this : (lsub fun i => sInf {b | f' i ≤ f b}) = a
⊢ cof (lsub fun i => sInf {b | f' i ≤ f b}) ≤ #ι
[PROOFSTEP]
apply cof_lsub_le
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
⊢ (lsub fun i => sInf {b | f' i ≤ f b}) = a
[PROOFSTEP]
have H : ∀ i, ∃ b < a, f' i ≤ f b := fun i => by
  have := lt_lsub.{u, u} f' i
  rw [hf', ← IsNormal.blsub_eq.{u, u} hf ha, lt_blsub_iff] at this
  simpa using this
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
i : ι
⊢ ∃ b, b < a ∧ f' i ≤ f b
[PROOFSTEP]
have := lt_lsub.{u, u} f' i
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
i : ι
this : f' i < lsub f'
⊢ ∃ b, b < a ∧ f' i ≤ f b
[PROOFSTEP]
rw [hf', ← IsNormal.blsub_eq.{u, u} hf ha, lt_blsub_iff] at this
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
i : ι
this : ∃ i_1 hi, f' i ≤ f i_1
⊢ ∃ b, b < a ∧ f' i ≤ f b
[PROOFSTEP]
simpa using this
[GOAL]
case refine'_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
⊢ (lsub fun i => sInf {b | f' i ≤ f b}) = a
[PROOFSTEP]
refine' (lsub_le fun i => _).antisymm (le_of_forall_lt fun b hb => _)
[GOAL]
case refine'_1.intro.intro.intro.refine'_1
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
i : ι
⊢ sInf {b | f' i ≤ f b} < a
[PROOFSTEP]
rcases H i with ⟨b, hb, hb'⟩
[GOAL]
case refine'_1.intro.intro.intro.refine'_1.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
i : ι
b : Ordinal.{u}
hb : b < a
hb' : f' i ≤ f b
⊢ sInf {b | f' i ≤ f b} < a
[PROOFSTEP]
exact lt_of_le_of_lt (csInf_le' hb') hb
[GOAL]
case refine'_1.intro.intro.intro.refine'_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
b : Ordinal.{u}
hb : b < a
⊢ b < lsub fun i => sInf {b | f' i ≤ f b}
[PROOFSTEP]
have := hf.strictMono hb
[GOAL]
case refine'_1.intro.intro.intro.refine'_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
b : Ordinal.{u}
hb : b < a
this : f b < f a
⊢ b < lsub fun i => sInf {b | f' i ≤ f b}
[PROOFSTEP]
rw [← hf', lt_lsub_iff] at this
[GOAL]
case refine'_1.intro.intro.intro.refine'_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
b : Ordinal.{u}
hb : b < a
this : ∃ i, f b ≤ f' i
⊢ b < lsub fun i => sInf {b | f' i ≤ f b}
[PROOFSTEP]
cases' this with i hi
[GOAL]
case refine'_1.intro.intro.intro.refine'_2.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
b : Ordinal.{u}
hb : b < a
i : ι
hi : f b ≤ f' i
⊢ b < lsub fun i => sInf {b | f' i ≤ f b}
[PROOFSTEP]
rcases H i with ⟨b, _, hb⟩
[GOAL]
case refine'_1.intro.intro.intro.refine'_2.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
b✝ : Ordinal.{u}
hb✝ : b✝ < a
i : ι
hi : f b✝ ≤ f' i
b : Ordinal.{u}
left✝ : b < a
hb : f' i ≤ f b
⊢ b✝ < lsub fun i => sInf {b | f' i ≤ f b}
[PROOFSTEP]
exact ((le_csInf_iff'' ⟨b, by exact hb⟩).2 fun c hc => hf.strictMono.le_iff_le.1 (hi.trans hc)).trans_lt (lt_lsub _ i)
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = cof (f a)
H : ∀ (i : ι), ∃ b, b < a ∧ f' i ≤ f b
b✝ : Ordinal.{u}
hb✝ : b✝ < a
i : ι
hi : f b✝ ≤ f' i
b : Ordinal.{u}
left✝ : b < a
hb : f' i ≤ f b
⊢ b ∈ fun c =>
    Quot.lift
      (fun a₁ =>
        Quotient.lift
          ((fun x x_1 =>
              match x with
              | { α := α, r := r, wo := wo } =>
                match x_1 with
                | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s))
            a₁)
          (_ :
            ∀ (a b : WellOrder),
              a ≈ b →
                (match a₁ with
                  | { α := α, r := r, wo := wo } =>
                    match a with
                    | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s)) =
                  match a₁ with
                  | { α := α, r := r, wo := wo } =>
                    match b with
                    | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s))
          (f c))
      (_ :
        ∀ (a b : WellOrder),
          a ≈ b →
            (fun a₁ =>
                  Quotient.lift
                    (fun x =>
                      match a₁ with
                      | { α := α, r := r, wo := wo } =>
                        match x with
                        | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s))
                    (_ :
                      ∀ (a b : WellOrder),
                        a ≈ b →
                          (fun x x_1 =>
                                match x with
                                | { α := α, r := r, wo := wo } =>
                                  match x_1 with
                                  | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s))
                              a₁ a =
                            (fun x x_1 =>
                                match x with
                                | { α := α, r := r, wo := wo } =>
                                  match x_1 with
                                  | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s))
                              a₁ b)
                    (f c))
                a =
              (fun a₁ =>
                  Quotient.lift
                    (fun x =>
                      match a₁ with
                      | { α := α, r := r, wo := wo } =>
                        match x with
                        | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s))
                    (_ :
                      ∀ (a b : WellOrder),
                        a ≈ b →
                          (fun x x_1 =>
                                match x with
                                | { α := α, r := r, wo := wo } =>
                                  match x_1 with
                                  | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s))
                              a₁ a =
                            (fun x x_1 =>
                                match x with
                                | { α := α, r := r, wo := wo } =>
                                  match x_1 with
                                  | { α := α_1, r := s, wo := wo } => Nonempty (r ≼i s))
                              a₁ b)
                    (f c))
                b)
      (f' i)
[PROOFSTEP]
exact hb
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
⊢ (blsub o fun b hb => f (g b hb)) = f a
[PROOFSTEP]
rw [@blsub_comp.{u, u, u} a _ (fun b _ => f b) (@fun i j _ _ h => hf.strictMono.monotone h) g hg.2.2]
[GOAL]
case refine'_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : IsLimit a
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : IsFundamentalSequence a o g
⊢ (blsub a fun b x => f b) = f a
[PROOFSTEP]
exact IsNormal.blsub_eq.{u, u} hf ha
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
hf : IsNormal f
a : Ordinal.{u_2}
⊢ cof a ≤ cof (f a)
[PROOFSTEP]
rcases zero_or_succ_or_limit a with (rfl | ⟨b, rfl⟩ | ha)
[GOAL]
case inl
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
hf : IsNormal f
⊢ cof 0 ≤ cof (f 0)
[PROOFSTEP]
rw [cof_zero]
[GOAL]
case inl
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
hf : IsNormal f
⊢ 0 ≤ cof (f 0)
[PROOFSTEP]
exact zero_le _
[GOAL]
case inr.inl.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
hf : IsNormal f
b : Ordinal.{u_2}
⊢ cof (succ b) ≤ cof (f (succ b))
[PROOFSTEP]
rw [cof_succ, Cardinal.one_le_iff_ne_zero, cof_ne_zero, ← Ordinal.pos_iff_ne_zero]
[GOAL]
case inr.inl.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
hf : IsNormal f
b : Ordinal.{u_2}
⊢ 0 < f (succ b)
[PROOFSTEP]
exact (Ordinal.zero_le (f b)).trans_lt (hf.1 b)
[GOAL]
case inr.inr
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
hf : IsNormal f
a : Ordinal.{u_2}
ha : IsLimit a
⊢ cof a ≤ cof (f a)
[PROOFSTEP]
rw [hf.cof_eq ha]
[GOAL]
α : Type u_1
r : α → α → Prop
a b : Ordinal.{u_2}
h : b ≠ 0
⊢ cof (a + b) = cof b
[PROOFSTEP]
rcases zero_or_succ_or_limit b with (rfl | ⟨c, rfl⟩ | hb)
[GOAL]
case inl
α : Type u_1
r : α → α → Prop
a : Ordinal.{u_2}
h : 0 ≠ 0
⊢ cof (a + 0) = cof 0
[PROOFSTEP]
contradiction
[GOAL]
case inr.inl.intro
α : Type u_1
r : α → α → Prop
a c : Ordinal.{u_2}
h : succ c ≠ 0
⊢ cof (a + succ c) = cof (succ c)
[PROOFSTEP]
rw [add_succ, cof_succ, cof_succ]
[GOAL]
case inr.inr
α : Type u_1
r : α → α → Prop
a b : Ordinal.{u_2}
h : b ≠ 0
hb : IsLimit b
⊢ cof (a + b) = cof b
[PROOFSTEP]
exact (add_isNormal a).cof_eq hb
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ ℵ₀ ≤ cof o ↔ IsLimit o
[PROOFSTEP]
rcases zero_or_succ_or_limit o with (rfl | ⟨o, rfl⟩ | l)
[GOAL]
case inl
α : Type u_1
r : α → α → Prop
⊢ ℵ₀ ≤ cof 0 ↔ IsLimit 0
[PROOFSTEP]
simp [not_zero_isLimit, Cardinal.aleph0_ne_zero]
[GOAL]
case inr.inl.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ ℵ₀ ≤ cof (succ o) ↔ IsLimit (succ o)
[PROOFSTEP]
simp [not_succ_isLimit, Cardinal.one_lt_aleph0]
[GOAL]
case inr.inr
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
⊢ ℵ₀ ≤ cof o ↔ IsLimit o
[PROOFSTEP]
simp [l]
[GOAL]
case inr.inr
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
⊢ ℵ₀ ≤ cof o
[PROOFSTEP]
refine' le_of_not_lt fun h => _
[GOAL]
case inr.inr
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
⊢ False
[PROOFSTEP]
cases' Cardinal.lt_aleph0.1 h with n e
[GOAL]
case inr.inr.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
n : ℕ
e : cof o = ↑n
⊢ False
[PROOFSTEP]
have := cof_cof o
[GOAL]
case inr.inr.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
n : ℕ
e : cof o = ↑n
this : cof (ord (cof o)) = cof o
⊢ False
[PROOFSTEP]
rw [e, ord_nat] at this
[GOAL]
case inr.inr.intro
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
n : ℕ
e : cof o = ↑n
this : cof ↑n = ↑n
⊢ False
[PROOFSTEP]
cases n
[GOAL]
case inr.inr.intro.zero
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
e : cof o = ↑Nat.zero
this : cof ↑Nat.zero = ↑Nat.zero
⊢ False
[PROOFSTEP]
simp at e
[GOAL]
case inr.inr.intro.zero
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
this : cof ↑Nat.zero = ↑Nat.zero
e : o = 0
⊢ False
[PROOFSTEP]
simp [e, not_zero_isLimit] at l
[GOAL]
case inr.inr.intro.succ
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
n✝ : ℕ
e : cof o = ↑(Nat.succ n✝)
this : cof ↑(Nat.succ n✝) = ↑(Nat.succ n✝)
⊢ False
[PROOFSTEP]
rw [nat_cast_succ, cof_succ] at this
[GOAL]
case inr.inr.intro.succ
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
n✝ : ℕ
e : cof o = ↑(Nat.succ n✝)
this : 1 = ↑(Nat.succ n✝)
⊢ False
[PROOFSTEP]
rw [← this, cof_eq_one_iff_is_succ] at e
[GOAL]
case inr.inr.intro.succ
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
l : IsLimit o
h : cof o < ℵ₀
n✝ : ℕ
e : ∃ a, o = succ a
this : 1 = ↑(Nat.succ n✝)
⊢ False
[PROOFSTEP]
rcases e with ⟨a, rfl⟩
[GOAL]
case inr.inr.intro.succ.intro
α : Type u_1
r : α → α → Prop
n✝ : ℕ
this : 1 = ↑(Nat.succ n✝)
a : Ordinal.{u_2}
l : IsLimit (succ a)
h : cof (succ a) < ℵ₀
⊢ False
[PROOFSTEP]
exact not_succ_isLimit _ l
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ cof ω ≤ ℵ₀
[PROOFSTEP]
rw [← card_omega]
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ cof ω ≤ card ω
[PROOFSTEP]
apply cof_le_card
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
h✝ : IsLimit (type r)
S : Set α
H : Unbounded r S
e : #↑S = cof (type r)
a : α
a' : α := enum r (succ (typein r a)) (_ : succ (typein r a) < type r)
b : α
h : b ∈ S
ab : ¬r b a'
⊢ typein r a < typein r a'
[PROOFSTEP]
rw [typein_enum]
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
inst✝ : IsWellOrder α r
h✝ : IsLimit (type r)
S : Set α
H : Unbounded r S
e : #↑S = cof (type r)
a : α
a' : α := enum r (succ (typein r a)) (_ : succ (typein r a) < type r)
b : α
h : b ∈ S
ab : ¬r b a'
⊢ typein r a < succ (typein r a)
[PROOFSTEP]
exact lt_succ (typein _ _)
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ Cardinal.univ ≤ cof univ
[PROOFSTEP]
refine' le_of_forall_lt fun c h => _
[GOAL]
α : Type u_1
r : α → α → Prop
c : Cardinal.{max (u + 1) v}
h : c < Cardinal.univ
⊢ c < cof univ
[PROOFSTEP]
rcases lt_univ'.1 h with ⟨c, rfl⟩
[GOAL]
case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : Cardinal.lift c < Cardinal.univ
⊢ Cardinal.lift c < cof univ
[PROOFSTEP]
rcases@cof_eq Ordinal.{u} (· < ·) _ with ⟨S, H, Se⟩
[GOAL]
case intro.intro.intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
⊢ Cardinal.lift c < cof univ
[PROOFSTEP]
rw [univ, ← lift_cof, ← Cardinal.lift_lift.{u + 1, v, u}, Cardinal.lift_lt, ← Se]
[GOAL]
case intro.intro.intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
⊢ Cardinal.lift c < #↑S
[PROOFSTEP]
refine' lt_of_not_ge fun h => _
[GOAL]
case intro.intro.intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h✝ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h : Cardinal.lift c ≥ #↑S
⊢ False
[PROOFSTEP]
cases' Cardinal.lift_down h with a e
[GOAL]
case intro.intro.intro.intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h✝ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e : Cardinal.lift a = #↑S
⊢ False
[PROOFSTEP]
refine' Quotient.inductionOn a (fun α e => _) e
[GOAL]
case intro.intro.intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
⊢ False
[PROOFSTEP]
cases' Quotient.exact e with f
[GOAL]
case intro.intro.intro.intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
f : ULift α ≃ ↑S
⊢ False
[PROOFSTEP]
have f := Equiv.ulift.symm.trans f
[GOAL]
case intro.intro.intro.intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
f✝ : ULift α ≃ ↑S
f : α ≃ ↑S
⊢ False
[PROOFSTEP]
let g a := (f a).1
[GOAL]
case intro.intro.intro.intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
f✝ : ULift α ≃ ↑S
f : α ≃ ↑S
g : α → Ordinal.{u} := fun a => ↑(↑f a)
⊢ False
[PROOFSTEP]
let o := succ (sup.{u, u} g)
[GOAL]
case intro.intro.intro.intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
f✝ : ULift α ≃ ↑S
f : α ≃ ↑S
g : α → Ordinal.{u} := fun a => ↑(↑f a)
o : Ordinal.{u} := succ (sup g)
⊢ False
[PROOFSTEP]
rcases H o with ⟨b, h, l⟩
[GOAL]
case intro.intro.intro.intro.intro.intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝¹ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h✝ : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
f✝ : ULift α ≃ ↑S
f : α ≃ ↑S
g : α → Ordinal.{u} := fun a => ↑(↑f a)
o : Ordinal.{u} := succ (sup g)
b : Ordinal.{u}
h : b ∈ S
l : ¬(fun x x_1 => x < x_1) b o
⊢ False
[PROOFSTEP]
refine' l (lt_succ_iff.2 _)
[GOAL]
case intro.intro.intro.intro.intro.intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝¹ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h✝ : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
f✝ : ULift α ≃ ↑S
f : α ≃ ↑S
g : α → Ordinal.{u} := fun a => ↑(↑f a)
o : Ordinal.{u} := succ (sup g)
b : Ordinal.{u}
h : b ∈ S
l : ¬(fun x x_1 => x < x_1) b o
⊢ b ≤ sup g
[PROOFSTEP]
rw [← show g (f.symm ⟨b, h⟩) = b by simp]
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝¹ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h✝ : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
f✝ : ULift α ≃ ↑S
f : α ≃ ↑S
g : α → Ordinal.{u} := fun a => ↑(↑f a)
o : Ordinal.{u} := succ (sup g)
b : Ordinal.{u}
h : b ∈ S
l : ¬(fun x x_1 => x < x_1) b o
⊢ g (↑f.symm { val := b, property := h }) = b
[PROOFSTEP]
simp
[GOAL]
case intro.intro.intro.intro.intro.intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h✝¹ : Cardinal.lift c < Cardinal.univ
S : Set Ordinal.{u}
H : Unbounded (fun x x_1 => x < x_1) S
Se : #↑S = cof (type fun x x_1 => x < x_1)
h✝ : Cardinal.lift c ≥ #↑S
a : Cardinal.{u}
e✝ : Cardinal.lift a = #↑S
α : Type u
e : Cardinal.lift (Quotient.mk Cardinal.isEquivalent α) = #↑S
f✝ : ULift α ≃ ↑S
f : α ≃ ↑S
g : α → Ordinal.{u} := fun a => ↑(↑f a)
o : Ordinal.{u} := succ (sup g)
b : Ordinal.{u}
h : b ∈ S
l : ¬(fun x x_1 => x < x_1) b o
⊢ g (↑f.symm { val := b, property := h }) ≤ sup g
[PROOFSTEP]
apply le_sup
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
⊢ ∃ x, x ∈ s ∧ Unbounded r x
[PROOFSTEP]
by_contra' h
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ (x : Set α), x ∈ s → ¬Unbounded r x
⊢ False
[PROOFSTEP]
simp_rw [not_unbounded_iff] at h
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ (x : Set α), x ∈ s → Bounded r x
⊢ False
[PROOFSTEP]
let f : s → α := fun x : s => wo.wf.sup x (h x.1 x.2)
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ (x : Set α), x ∈ s → Bounded r x
f : ↑s → α := fun x => WellFounded.sup (_ : WellFounded r) ↑x (_ : Bounded r ↑x)
⊢ False
[PROOFSTEP]
refine' h₂.not_le (le_trans (csInf_le' ⟨range f, fun x => _, rfl⟩) mk_range_le)
[GOAL]
α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ (x : Set α), x ∈ s → Bounded r x
f : ↑s → α := fun x => WellFounded.sup (_ : WellFounded r) ↑x (_ : Bounded r ↑x)
x : α
⊢ ∃ b, b ∈ range f ∧ swap rᶜ x b
[PROOFSTEP]
rcases h₁ x with ⟨y, ⟨c, hc, hy⟩, hxy⟩
[GOAL]
case intro.intro.intro.intro
α : Type u_1
r✝ r : α → α → Prop
wo : IsWellOrder α r
s : Set (Set α)
h₁ : Unbounded r (⋃₀ s)
h₂ : #↑s < StrictOrder.cof r
h : ∀ (x : Set α), x ∈ s → Bounded r x
f : ↑s → α := fun x => WellFounded.sup (_ : WellFounded r) ↑x (_ : Bounded r ↑x)
x y : α
hxy : ¬r y x
c : Set α
hc : c ∈ s
hy : y ∈ c
⊢ ∃ b, b ∈ range f ∧ swap rᶜ x b
[PROOFSTEP]
exact ⟨f ⟨c, hc⟩, mem_range_self _, fun hxz => hxy (Trans.trans (wo.wf.lt_sup _ hy) hxz)⟩
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃ (x : β), s x)
h₂ : #β < StrictOrder.cof r
⊢ ∃ x, Unbounded r (s x)
[PROOFSTEP]
rw [← sUnion_range] at h₁
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃₀ range fun x => s x)
h₂ : #β < StrictOrder.cof r
⊢ ∃ x, Unbounded r (s x)
[PROOFSTEP]
rcases unbounded_of_unbounded_sUnion r h₁ (mk_range_le.trans_lt h₂) with ⟨_, ⟨x, rfl⟩, u⟩
[GOAL]
case intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α β : Type u
r : α → α → Prop
wo : IsWellOrder α r
s : β → Set α
h₁ : Unbounded r (⋃₀ range fun x => s x)
h₂ : #β < StrictOrder.cof r
x : β
u : Unbounded r ((fun x => s x) x)
⊢ ∃ x, Unbounded r (s x)
[PROOFSTEP]
exact ⟨x, u⟩
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
⊢ ∃ a, #↑(f ⁻¹' {a}) = #β
[PROOFSTEP]
have : ∃ a, #β ≤ #(f ⁻¹' { a }) := by
  by_contra' h
  apply mk_univ.not_lt
  rw [← preimage_univ, ← iUnion_of_singleton, preimage_iUnion]
  exact
    mk_iUnion_le_sum_mk.trans_lt
      ((sum_le_iSup _).trans_lt <| mul_lt_of_lt h₁ (h₂.trans_le <| cof_ord_le _) (iSup_lt h₂ h))
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
⊢ ∃ a, #β ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
by_contra' h
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
h : ∀ (a : α), #↑(f ⁻¹' {a}) < #β
⊢ False
[PROOFSTEP]
apply mk_univ.not_lt
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
h : ∀ (a : α), #↑(f ⁻¹' {a}) < #β
⊢ #↑Set.univ < #?m.111025
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
h : ∀ (a : α), #↑(f ⁻¹' {a}) < #β
⊢ Type ?u.111024
[PROOFSTEP]
rw [← preimage_univ, ← iUnion_of_singleton, preimage_iUnion]
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
h : ∀ (a : α), #↑(f ⁻¹' {a}) < #β
⊢ #↑(⋃ (i : ?m.111092), ?m.111093 ⁻¹' {i}) < #?m.111090
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
h : ∀ (a : α), #↑(f ⁻¹' {a}) < #β
⊢ Type ?u.111087
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
h : ∀ (a : α), #↑(f ⁻¹' {a}) < #β
⊢ Type ?u.111088
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
h : ∀ (a : α), #↑(f ⁻¹' {a}) < #β
⊢ ?m.111090 → ?m.111092
[PROOFSTEP]
exact
  mk_iUnion_le_sum_mk.trans_lt
    ((sum_le_iSup _).trans_lt <| mul_lt_of_lt h₁ (h₂.trans_le <| cof_ord_le _) (iSup_lt h₂ h))
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
this : ∃ a, #β ≤ #↑(f ⁻¹' {a})
⊢ ∃ a, #↑(f ⁻¹' {a}) = #β
[PROOFSTEP]
cases' this with x h
[GOAL]
case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ ∃ a, #↑(f ⁻¹' {a}) = #β
[PROOFSTEP]
refine' ⟨x, h.antisymm' _⟩
[GOAL]
case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ #↑(f ⁻¹' {x}) ≤ #β
[PROOFSTEP]
rw [le_mk_iff_exists_set]
[GOAL]
case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
h₁ : ℵ₀ ≤ #β
h₂ : #α < cof (ord #β)
x : α
h : #β ≤ #↑(f ⁻¹' {x})
⊢ ∃ p, #↑p = #↑(f ⁻¹' {x})
[PROOFSTEP]
exact ⟨_, rfl⟩
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
θ : Cardinal.{u}
hθ : θ ≤ #β
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
⊢ ∃ a, θ ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
rcases le_mk_iff_exists_set.1 hθ with ⟨s, rfl⟩
[GOAL]
case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
s : Set β
hθ : #↑s ≤ #β
h₁ : ℵ₀ ≤ #↑s
h₂ : #α < cof (ord #↑s)
⊢ ∃ a, #↑s ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
cases' infinite_pigeonhole (f ∘ Subtype.val : s → α) h₁ h₂ with a ha
[GOAL]
case intro.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
s : Set β
hθ : #↑s ≤ #β
h₁ : ℵ₀ ≤ #↑s
h₂ : #α < cof (ord #↑s)
a : α
ha : #↑(f ∘ Subtype.val ⁻¹' {a}) = #↑s
⊢ ∃ a, #↑s ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
use a
[GOAL]
case h
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
s : Set β
hθ : #↑s ≤ #β
h₁ : ℵ₀ ≤ #↑s
h₂ : #α < cof (ord #↑s)
a : α
ha : #↑(f ∘ Subtype.val ⁻¹' {a}) = #↑s
⊢ #↑s ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
rw [← ha, @preimage_comp _ _ _ Subtype.val f]
[GOAL]
case h
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
s : Set β
hθ : #↑s ≤ #β
h₁ : ℵ₀ ≤ #↑s
h₂ : #α < cof (ord #↑s)
a : α
ha : #↑(f ∘ Subtype.val ⁻¹' {a}) = #↑s
⊢ #↑(Subtype.val ⁻¹' (f ⁻¹' {a})) ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
exact mk_preimage_of_injective _ _ Subtype.val_injective
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
⊢ ∃ a t h, θ ≤ #↑t ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f { val := x, property := (_ : x ∈ s) } = a
[PROOFSTEP]
cases' infinite_pigeonhole_card f θ hθ h₁ h₂ with a ha
[GOAL]
case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ ∃ a t h, θ ≤ #↑t ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f { val := x, property := (_ : x ∈ s) } = a
[PROOFSTEP]
refine' ⟨a, {x | ∃ h, f ⟨x, h⟩ = a}, _, _, _⟩
[GOAL]
case intro.refine'_1
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ {x | ∃ h, f { val := x, property := h } = a} ⊆ s
[PROOFSTEP]
rintro x ⟨hx, _⟩
[GOAL]
case intro.refine'_1.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
x : β
hx : x ∈ s
h✝ : f { val := x, property := hx } = a
⊢ x ∈ s
[PROOFSTEP]
exact hx
[GOAL]
case intro.refine'_2
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ θ ≤ #↑{x | ∃ h, f { val := x, property := h } = a}
[PROOFSTEP]
refine' ha.trans (ge_of_eq <| Quotient.sound ⟨Equiv.trans _ (Equiv.subtypeSubtypeEquivSubtypeExists _ _).symm⟩)
[GOAL]
case intro.refine'_2
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ ↑{x | ∃ h, f { val := x, property := h } = a} ≃ { a_1 // ∃ h, { val := a_1, property := h } ∈ f ⁻¹' {a} }
[PROOFSTEP]
simp only [coe_eq_subtype, mem_singleton_iff, mem_preimage, mem_setOf_eq]
[GOAL]
case intro.refine'_2
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ { x // ∃ h, f { val := x, property := h } = a } ≃ { a_1 // ∃ h, f { val := a_1, property := (_ : a_1 ∈ s) } = a }
[PROOFSTEP]
rfl
[GOAL]
case intro.refine'_3
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ ∀ ⦃x : β⦄ (hx : x ∈ {x | ∃ h, f { val := x, property := h } = a}), f { val := x, property := (_ : x ∈ s) } = a
[PROOFSTEP]
rintro x ⟨_, hx'⟩
[GOAL]
case intro.refine'_3.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < cof (ord θ)
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
x : β
w✝ : x ∈ s
hx' : f { val := x, property := w✝ } = a
⊢ f { val := x, property := (_ : x ∈ s) } = a
[PROOFSTEP]
exact hx'
[GOAL]
α : Type u_1
r : α → α → Prop
x : Cardinal.{u_2}
hx : x < ℵ₀
⊢ 2 ^ x < ℵ₀
[PROOFSTEP]
rcases lt_aleph0.1 hx with ⟨n, rfl⟩
[GOAL]
case intro
α : Type u_1
r : α → α → Prop
n : ℕ
hx : ↑n < ℵ₀
⊢ 2 ^ ↑n < ℵ₀
[PROOFSTEP]
exact_mod_cast nat_lt_aleph0 (2 ^ n)
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
H : IsSuccLimit o
⊢ IsStrongLimit (beth o)
[PROOFSTEP]
rcases eq_or_ne o 0 with (rfl | h)
[GOAL]
case inl
α : Type u_1
r : α → α → Prop
H : IsSuccLimit 0
⊢ IsStrongLimit (beth 0)
[PROOFSTEP]
rw [beth_zero]
[GOAL]
case inl
α : Type u_1
r : α → α → Prop
H : IsSuccLimit 0
⊢ IsStrongLimit ℵ₀
[PROOFSTEP]
exact isStrongLimit_aleph0
[GOAL]
case inr
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
H : IsSuccLimit o
h : o ≠ 0
⊢ IsStrongLimit (beth o)
[PROOFSTEP]
refine' ⟨beth_ne_zero o, fun a ha => _⟩
[GOAL]
case inr
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
H : IsSuccLimit o
h : o ≠ 0
a : Cardinal.{u_2}
ha : a < beth o
⊢ 2 ^ a < beth o
[PROOFSTEP]
rw [beth_limit ⟨h, isSuccLimit_iff_succ_lt.1 H⟩] at ha
[GOAL]
case inr
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
H : IsSuccLimit o
h : o ≠ 0
a : Cardinal.{u_2}
ha : a < ⨆ (a : ↑(Iio o)), beth ↑a
⊢ 2 ^ a < beth o
[PROOFSTEP]
rcases exists_lt_of_lt_ciSup' ha with ⟨⟨i, hi⟩, ha⟩
[GOAL]
case inr.intro.mk
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
H : IsSuccLimit o
h : o ≠ 0
a : Cardinal.{u_2}
ha✝ : a < ⨆ (a : ↑(Iio o)), beth ↑a
i : Ordinal.{u_2}
hi : i ∈ Iio o
ha : a < beth ↑{ val := i, property := hi }
⊢ 2 ^ a < beth o
[PROOFSTEP]
have := power_le_power_left two_ne_zero ha.le
[GOAL]
case inr.intro.mk
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
H : IsSuccLimit o
h : o ≠ 0
a : Cardinal.{u_2}
ha✝ : a < ⨆ (a : ↑(Iio o)), beth ↑a
i : Ordinal.{u_2}
hi : i ∈ Iio o
ha : a < beth ↑{ val := i, property := hi }
this : 2 ^ a ≤ 2 ^ beth ↑{ val := i, property := hi }
⊢ 2 ^ a < beth o
[PROOFSTEP]
rw [← beth_succ] at this
[GOAL]
case inr.intro.mk
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
H : IsSuccLimit o
h : o ≠ 0
a : Cardinal.{u_2}
ha✝ : a < ⨆ (a : ↑(Iio o)), beth ↑a
i : Ordinal.{u_2}
hi : i ∈ Iio o
ha : a < beth ↑{ val := i, property := hi }
this : 2 ^ a ≤ beth (succ ↑{ val := i, property := hi })
⊢ 2 ^ a < beth o
[PROOFSTEP]
exact this.trans_lt (beth_lt.2 (H.succ_lt hi))
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
⊢ #{ s // Bounded r s } = #α
[PROOFSTEP]
rcases eq_or_ne (#α) 0 with (ha | ha)
[GOAL]
case inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha : #α = 0
⊢ #{ s // Bounded r s } = #α
[PROOFSTEP]
rw [ha]
[GOAL]
case inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha : #α = 0
⊢ #{ s // Bounded r s } = 0
[PROOFSTEP]
haveI := mk_eq_zero_iff.1 ha
[GOAL]
case inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha : #α = 0
this : IsEmpty α
⊢ #{ s // Bounded r s } = 0
[PROOFSTEP]
rw [mk_eq_zero_iff]
[GOAL]
case inl
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha : #α = 0
this : IsEmpty α
⊢ IsEmpty { s // Bounded r s }
[PROOFSTEP]
constructor
[GOAL]
case inl.false
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha : #α = 0
this : IsEmpty α
⊢ { s // Bounded r s } → False
[PROOFSTEP]
rintro ⟨s, hs⟩
[GOAL]
case inl.false.mk
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha : #α = 0
this : IsEmpty α
s : Set α
hs : Bounded r s
⊢ False
[PROOFSTEP]
exact (not_unbounded_iff s).2 hs (unbounded_of_isEmpty s)
[GOAL]
case inr
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha : #α ≠ 0
⊢ #{ s // Bounded r s } = #α
[PROOFSTEP]
have h' : IsStrongLimit #α := ⟨ha, h⟩
[GOAL]
case inr
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha : #α ≠ 0
h' : IsStrongLimit #α
⊢ #{ s // Bounded r s } = #α
[PROOFSTEP]
have ha := h'.isLimit.aleph0_le
[GOAL]
case inr
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
⊢ #{ s // Bounded r s } = #α
[PROOFSTEP]
apply le_antisymm
[GOAL]
case inr.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
⊢ #{ s // Bounded r s } ≤ #α
[PROOFSTEP]
have : {s : Set α | Bounded r s} = ⋃ i, 𝒫{j | r j i} := setOf_exists _
[GOAL]
case inr.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
⊢ #{ s // Bounded r s } ≤ #α
[PROOFSTEP]
rw [← coe_setOf, this]
[GOAL]
case inr.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
⊢ #↑(⋃ (i : α), 𝒫{j | r j i}) ≤ #α
[PROOFSTEP]
refine
  mk_iUnion_le_sum_mk.trans
    ((sum_le_iSup (fun i => #(𝒫{j | r j i}))).trans ((mul_le_max_of_aleph0_le_left ha).trans ?_))
[GOAL]
case inr.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
⊢ max (#α) (⨆ (i : α), #↑(𝒫{j | r j i})) ≤ #α
[PROOFSTEP]
rw [max_eq_left]
[GOAL]
case inr.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
⊢ ⨆ (i : α), #↑(𝒫{j | r j i}) ≤ #α
[PROOFSTEP]
apply ciSup_le' _
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
⊢ ∀ (i : α), #↑(𝒫{j | r j i}) ≤ #α
[PROOFSTEP]
intro i
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
i : α
⊢ #↑(𝒫{j | r j i}) ≤ #α
[PROOFSTEP]
rw [mk_powerset]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
i : α
⊢ 2 ^ #↑{j | r j i} ≤ #α
[PROOFSTEP]
apply (h'.two_power_lt _).le
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
i : α
⊢ #↑{j | r j i} < #α
[PROOFSTEP]
rw [coe_setOf, card_typein, ← lt_ord, hr]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
this : {s | Bounded r s} = ⋃ (i : α), 𝒫{j | r j i}
i : α
⊢ typein (fun x => r x) i < type r
[PROOFSTEP]
apply typein_lt_type
[GOAL]
case inr.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
⊢ #α ≤ #{ s // Bounded r s }
[PROOFSTEP]
refine' @mk_le_of_injective α _ (fun x => Subtype.mk { x } _) _
[GOAL]
case inr.a.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
x : α
⊢ Bounded r {x}
[PROOFSTEP]
apply bounded_singleton
[GOAL]
case inr.a.refine'_1.hr
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
x : α
⊢ Ordinal.IsLimit (type r)
[PROOFSTEP]
rw [← hr]
[GOAL]
case inr.a.refine'_1.hr
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
x : α
⊢ Ordinal.IsLimit (ord #α)
[PROOFSTEP]
apply ord_isLimit ha
[GOAL]
case inr.a.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
⊢ Injective fun x => { val := {x}, property := (_ : Bounded r {x}) }
[PROOFSTEP]
intro a b hab
[GOAL]
case inr.a.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
r : α → α → Prop
inst✝ : IsWellOrder α r
hr : ord #α = type r
ha✝ : #α ≠ 0
h' : IsStrongLimit #α
ha : ℵ₀ ≤ #α
a b : α
hab :
  (fun x => { val := {x}, property := (_ : Bounded r {x}) }) a =
    (fun x => { val := {x}, property := (_ : Bounded r {x}) }) b
⊢ a = b
[PROOFSTEP]
simpa [singleton_eq_singleton_iff] using hab
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
⊢ #{ s // #↑s < Ordinal.cof (ord #α) } = #α
[PROOFSTEP]
rcases eq_or_ne (#α) 0 with (ha | ha)
[GOAL]
case inl
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α = 0
⊢ #{ s // #↑s < Ordinal.cof (ord #α) } = #α
[PROOFSTEP]
rw [ha]
[GOAL]
case inl
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α = 0
⊢ #{ s // #↑s < Ordinal.cof (ord 0) } = 0
[PROOFSTEP]
simp [fun s => (Cardinal.zero_le s).not_lt]
[GOAL]
case inr
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
⊢ #{ s // #↑s < Ordinal.cof (ord #α) } = #α
[PROOFSTEP]
have h' : IsStrongLimit #α := ⟨ha, h⟩
[GOAL]
case inr
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
⊢ #{ s // #↑s < Ordinal.cof (ord #α) } = #α
[PROOFSTEP]
rcases ord_eq α with ⟨r, wo, hr⟩
[GOAL]
case inr.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
⊢ #{ s // #↑s < Ordinal.cof (ord #α) } = #α
[PROOFSTEP]
haveI := wo
[GOAL]
case inr.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
⊢ #{ s // #↑s < Ordinal.cof (ord #α) } = #α
[PROOFSTEP]
apply le_antisymm
[GOAL]
case inr.intro.intro.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
⊢ #{ s // #↑s < Ordinal.cof (ord #α) } ≤ #α
[PROOFSTEP]
conv_rhs => rw [← mk_bounded_subset h hr]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
| #α
[PROOFSTEP]
rw [← mk_bounded_subset h hr]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
| #α
[PROOFSTEP]
rw [← mk_bounded_subset h hr]
[GOAL]
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
| #α
[PROOFSTEP]
rw [← mk_bounded_subset h hr]
[GOAL]
case inr.intro.intro.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
⊢ #{ s // #↑s < Ordinal.cof (ord #α) } ≤ #{ s // Bounded r s }
[PROOFSTEP]
apply mk_le_mk_of_subset
[GOAL]
case inr.intro.intro.a.h
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
⊢ (fun x =>
      Quotient.liftOn₂ (#↑x) (Ordinal.cof (ord #α)) (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1 ∧
        ¬Quotient.liftOn₂ (Ordinal.cof (ord #α)) (#↑x) (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1) ⊆
    fun x => ∃ a, ∀ (b : α), b ∈ x → r b a
[PROOFSTEP]
intro s hs
[GOAL]
case inr.intro.intro.a.h
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
s : Set α
hs :
  s ∈ fun x =>
    Quotient.liftOn₂ (#↑x) (Ordinal.cof (ord #α)) (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1 ∧
      ¬Quotient.liftOn₂ (Ordinal.cof (ord #α)) (#↑x) (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1
⊢ s ∈ fun x => ∃ a, ∀ (b : α), b ∈ x → r b a
[PROOFSTEP]
rw [hr] at hs
[GOAL]
case inr.intro.intro.a.h
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
s : Set α
hs :
  s ∈ fun x =>
    Quotient.liftOn₂ (#↑x) (Ordinal.cof (type r)) (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1 ∧
      ¬Quotient.liftOn₂ (Ordinal.cof (type r)) (#↑x) (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1
⊢ s ∈ fun x => ∃ a, ∀ (b : α), b ∈ x → r b a
[PROOFSTEP]
exact lt_cof_type hs
[GOAL]
case inr.intro.intro.a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
⊢ #α ≤ #{ s // #↑s < Ordinal.cof (ord #α) }
[PROOFSTEP]
refine' @mk_le_of_injective α _ (fun x => Subtype.mk { x } _) _
[GOAL]
case inr.intro.intro.a.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
x : α
⊢ #↑{x} < Ordinal.cof (ord #α)
[PROOFSTEP]
rw [mk_singleton]
[GOAL]
case inr.intro.intro.a.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
x : α
⊢ 1 < Ordinal.cof (ord #α)
[PROOFSTEP]
exact one_lt_aleph0.trans_le (aleph0_le_cof.2 (ord_isLimit h'.isLimit.aleph0_le))
[GOAL]
case inr.intro.intro.a.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
⊢ Injective fun x => { val := {x}, property := (_ : #↑{x} < Ordinal.cof (ord #α)) }
[PROOFSTEP]
intro a b hab
[GOAL]
case inr.intro.intro.a.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
α : Type u_2
h : ∀ (x : Cardinal.{u_2}), x < #α → 2 ^ x < #α
ha : #α ≠ 0
h' : IsStrongLimit #α
r : α → α → Prop
wo : IsWellOrder α r
hr : ord #α = type r
this : IsWellOrder α r
a b : α
hab :
  (fun x => { val := {x}, property := (_ : #↑{x} < Ordinal.cof (ord #α)) }) a =
    (fun x => { val := {x}, property := (_ : #↑{x} < Ordinal.cof (ord #α)) }) b
⊢ a = b
[PROOFSTEP]
simpa [singleton_eq_singleton_iff] using hab
[GOAL]
α : Type u_1
r : α → α → Prop
c : Cardinal.{u_2}
H : IsRegular c
⊢ 0 < ord c
[PROOFSTEP]
rw [Cardinal.lt_ord, card_zero]
[GOAL]
α : Type u_1
r : α → α → Prop
c : Cardinal.{u_2}
H : IsRegular c
⊢ 0 < c
[PROOFSTEP]
exact H.pos
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ ℵ₀ ≤ Ordinal.cof (ord ℵ₀)
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
⊢ c < Ordinal.cof (ord (succ c))
[PROOFSTEP]
cases' Quotient.exists_rep (@succ Cardinal _ _ c) with α αe
[GOAL]
case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : Quotient.mk isEquivalent α = succ c
⊢ c < Ordinal.cof (ord (succ c))
[PROOFSTEP]
simp at αe
[GOAL]
case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
⊢ c < Ordinal.cof (ord (succ c))
[PROOFSTEP]
rcases ord_eq α with ⟨r, wo, re⟩
[GOAL]
case intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
⊢ c < Ordinal.cof (ord (succ c))
[PROOFSTEP]
skip
[GOAL]
case intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
⊢ c < Ordinal.cof (ord (succ c))
[PROOFSTEP]
have := ord_isLimit (h.trans (le_succ _))
[GOAL]
case intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (ord (succ c))
⊢ c < Ordinal.cof (ord (succ c))
[PROOFSTEP]
rw [← αe, re] at this ⊢
[GOAL]
case intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
⊢ c < Ordinal.cof (type r)
[PROOFSTEP]
rcases cof_eq' r this with ⟨S, H, Se⟩
[GOAL]
case intro.intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
⊢ c < Ordinal.cof (type r)
[PROOFSTEP]
rw [← Se]
[GOAL]
case intro.intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
⊢ c < #↑S
[PROOFSTEP]
apply lt_imp_lt_of_le_imp_le fun h => mul_le_mul_right' h c
[GOAL]
case intro.intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
⊢ c * c < #↑S * c
[PROOFSTEP]
rw [mul_eq_self h, ← succ_le_iff, ← αe, ← sum_const']
[GOAL]
case intro.intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
⊢ #α ≤ sum fun x => c
[PROOFSTEP]
refine' le_trans _ (sum_le_sum (fun (x : S) => card (typein r (x : α))) _ fun i => _)
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
⊢ #α ≤ sum fun x => card (typein r ↑x)
[PROOFSTEP]
simp only [← card_typein, ← mk_sigma]
[GOAL]
case intro.intro.intro.intro.intro.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
⊢ #α ≤ #((i : ↑S) × { y // r y ↑i })
[PROOFSTEP]
exact
  ⟨Embedding.ofSurjective (fun x => x.2.1) fun a =>
      let ⟨b, h, ab⟩ := H a
      ⟨⟨⟨_, h⟩, _, ab⟩, rfl⟩⟩
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
i : ↑S
⊢ (fun x => card (typein r ↑x)) i ≤ c
[PROOFSTEP]
rw [← lt_succ_iff, ← lt_ord, ← αe, re]
[GOAL]
case intro.intro.intro.intro.intro.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
h : ℵ₀ ≤ c
α : Type u
αe : #α = succ c
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
i : ↑S
⊢ typein r ↑i < type r
[PROOFSTEP]
apply typein_lt_type
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ IsRegular (aleph 1)
[PROOFSTEP]
rw [← succ_aleph0]
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ IsRegular (succ ℵ₀)
[PROOFSTEP]
exact isRegular_succ le_rfl
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
h : ω ≤ o
⊢ IsRegular (aleph' (succ o))
[PROOFSTEP]
rw [aleph'_succ]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
h : ω ≤ o
⊢ IsRegular (succ (aleph' o))
[PROOFSTEP]
exact isRegular_succ (aleph0_le_aleph'.2 h)
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ IsRegular (aleph (succ o))
[PROOFSTEP]
rw [aleph_succ]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u_2}
⊢ IsRegular (succ (aleph o))
[PROOFSTEP]
exact isRegular_succ (aleph0_le_aleph o)
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : #α < #β
w' : ℵ₀ ≤ #α
⊢ ∃ a, #α < #↑(f ⁻¹' {a})
[PROOFSTEP]
simp_rw [← succ_le_iff]
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : #α < #β
w' : ℵ₀ ≤ #α
⊢ ∃ a, succ #α ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
exact
  Ordinal.infinite_pigeonhole_card f (succ #α) (succ_le_of_lt w) (w'.trans (lt_succ _).le)
    ((lt_succ _).trans_le (isRegular_succ w').2.ge)
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u_2
f : β → α
w : #α < #β
w' : Infinite α
⊢ ∃ a, Infinite ↑(f ⁻¹' {a})
[PROOFSTEP]
simp_rw [Cardinal.infinite_iff] at w' ⊢
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u_2
f : β → α
w : #α < #β
w' : ℵ₀ ≤ #α
⊢ ∃ a, ℵ₀ ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
cases' infinite_pigeonhole_card_lt f w w' with a ha
[GOAL]
case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u_2
f : β → α
w : #α < #β
w' : ℵ₀ ≤ #α
a : α
ha : #α < #↑(f ⁻¹' {a})
⊢ ∃ a, ℵ₀ ≤ #↑(f ⁻¹' {a})
[PROOFSTEP]
exact ⟨a, w'.trans ha.le⟩
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
⊢ #β ≤ #↑(range f)
[PROOFSTEP]
have k : _root_.Infinite (range f) := by
  rw [infinite_coe_iff]
  apply mt (union_finset_finite_of_range_finite f)
  rw [w]
  exact infinite_univ
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
⊢ Infinite ↑(range f)
[PROOFSTEP]
rw [infinite_coe_iff]
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
⊢ Set.Infinite (range f)
[PROOFSTEP]
apply mt (union_finset_finite_of_range_finite f)
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
⊢ ¬Set.Finite (⋃ (a : α), ↑(f a))
[PROOFSTEP]
rw [w]
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
⊢ ¬Set.Finite ⊤
[PROOFSTEP]
exact infinite_univ
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
⊢ #β ≤ #↑(range f)
[PROOFSTEP]
by_contra h
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : ¬#β ≤ #↑(range f)
⊢ False
[PROOFSTEP]
simp only [not_le] at h
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
⊢ False
[PROOFSTEP]
let u : ∀ b, ∃ a, b ∈ f a := fun b => by simpa using (w.ge : _) (Set.mem_univ b)
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
b : β
⊢ ∃ a, b ∈ f a
[PROOFSTEP]
simpa using (w.ge : _) (Set.mem_univ b)
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
⊢ False
[PROOFSTEP]
let u' : β → range f := fun b => ⟨f (u b).choose, by simp⟩
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
b : β
⊢ f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f
[PROOFSTEP]
simp
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
u' : β → ↑(range f) :=
  fun b =>
    { val := f (Exists.choose (_ : ∃ a, b ∈ f a)), property := (_ : f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f) }
⊢ False
[PROOFSTEP]
have v' : ∀ a, u' ⁻¹' {⟨f a, by simp⟩} ≤ f a := by
  rintro a p m
  simp at m
  rw [← m]
  apply fun b => (u b).choose_spec
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
u' : β → ↑(range f) :=
  fun b =>
    { val := f (Exists.choose (_ : ∃ a, b ∈ f a)), property := (_ : f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f) }
a : α
⊢ f a ∈ range f
[PROOFSTEP]
simp
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
u' : β → ↑(range f) :=
  fun b =>
    { val := f (Exists.choose (_ : ∃ a, b ∈ f a)), property := (_ : f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f) }
⊢ ∀ (a : α), u' ⁻¹' {{ val := f a, property := (_ : f a ∈ range f) }} ≤ ↑(f a)
[PROOFSTEP]
rintro a p m
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
u' : β → ↑(range f) :=
  fun b =>
    { val := f (Exists.choose (_ : ∃ a, b ∈ f a)), property := (_ : f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f) }
a : α
p : β
m : p ∈ u' ⁻¹' {{ val := f a, property := (_ : f a ∈ range f) }}
⊢ p ∈ ↑(f a)
[PROOFSTEP]
simp at m
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
u' : β → ↑(range f) :=
  fun b =>
    { val := f (Exists.choose (_ : ∃ a, b ∈ f a)), property := (_ : f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f) }
a : α
p : β
m : f (Exists.choose (_ : ∃ a, p ∈ f a)) = f a
⊢ p ∈ ↑(f a)
[PROOFSTEP]
rw [← m]
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
u' : β → ↑(range f) :=
  fun b =>
    { val := f (Exists.choose (_ : ∃ a, b ∈ f a)), property := (_ : f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f) }
a : α
p : β
m : f (Exists.choose (_ : ∃ a, p ∈ f a)) = f a
⊢ p ∈ ↑(f (Exists.choose (_ : ∃ a, p ∈ f a)))
[PROOFSTEP]
apply fun b => (u b).choose_spec
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
u' : β → ↑(range f) :=
  fun b =>
    { val := f (Exists.choose (_ : ∃ a, b ∈ f a)), property := (_ : f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f) }
v' : ∀ (a : α), u' ⁻¹' {{ val := f a, property := (_ : f a ∈ range f) }} ≤ ↑(f a)
⊢ False
[PROOFSTEP]
obtain ⟨⟨-, ⟨a, rfl⟩⟩, p⟩ := exists_infinite_fiber u' h k
[GOAL]
case intro.mk.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
α : Type u_2
β : Type u_3
inst✝ : Infinite β
f : α → Finset β
w : ⋃ (a : α), ↑(f a) = ⊤
k : Infinite ↑(range f)
h : #↑(range f) < #β
u : ∀ (b : β), ∃ a, b ∈ f a :=
  fun b =>
    Eq.mp
      (Eq.trans Mathlib.Data.Set.Lattice._auxLemma.3
        (congrArg Exists (funext fun i => Mathlib.Data.Finset.Basic._auxLemma.4)))
      (Eq.ge w (mem_univ b))
u' : β → ↑(range f) :=
  fun b =>
    { val := f (Exists.choose (_ : ∃ a, b ∈ f a)), property := (_ : f (Exists.choose (_ : ∃ a, b ∈ f a)) ∈ range f) }
v' : ∀ (a : α), u' ⁻¹' {{ val := f a, property := (_ : f a ∈ range f) }} ≤ ↑(f a)
a : α
p : Infinite ↑(u' ⁻¹' {{ val := f a, property := (_ : ∃ y, f y = f a) }})
⊢ False
[PROOFSTEP]
exact (@Infinite.of_injective _ _ p (inclusion (v' a)) (inclusion_injective _)).false
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
⊢ lift #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type (max u_2 u_3)
f : ι → Ordinal.{max u_2 u_3}
c : Cardinal.{max u_2 u_3}
hc : IsRegular c
hι : #ι < c
⊢ #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
⊢ lift #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type (max u_2 u_3)
f : ι → Ordinal.{max u_2 u_3}
c : Cardinal.{max u_2 u_3}
hc : IsRegular c
hι : #ι < c
⊢ #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
ho : lift (card o) < c
⊢ lift (card o) < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{max u_2 u_3}
f : (a : Ordinal.{max u_2 u_3}) → a < o → Ordinal.{max u_2 u_3}
c : Cardinal.{max u_2 u_3}
hc : IsRegular c
ho : card o < c
⊢ card o < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift (card o) < c
⊢ lift (card o) < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{max u_2 u_3}
f : (a : Ordinal.{max u_2 u_3}) → a < o → Ordinal.{max u_2 u_3}
c : Cardinal.{max u_2 u_3}
hc : IsRegular c
hι : card o < c
⊢ card o < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
⊢ lift #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u_2
f : ι → Cardinal.{u_2}
c : Cardinal.{u_2}
hc : IsRegular c
hι : #ι < c
⊢ #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{u}
c : Cardinal.{u}
hc : IsRegular c
hι : #ι < c
⊢ lift #ι < c
[PROOFSTEP]
rwa [lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
ha : a < ord c
⊢ nfpFamily f a < ord c
[PROOFSTEP]
apply nfpFamily_lt_ord_lift.{u, v} _ _ hf ha
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
ha : a < ord c
⊢ ℵ₀ < Ordinal.cof (ord c)
[PROOFSTEP]
rw [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
ha : a < ord c
⊢ lift #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rw [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
ha : a < ord c
⊢ ℵ₀ < c
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
ha : a < ord c
⊢ lift #ι < c
[PROOFSTEP]
exact lt_of_le_of_ne hc.1 hc'.symm
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
ha : a < ord c
⊢ lift #ι < c
[PROOFSTEP]
exact hι
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u} → Ordinal.{u}
c : Cardinal.{u}
hc : IsRegular c
hι : #ι < c
hc' : c ≠ ℵ₀
a : Ordinal.{u}
hf : ∀ (i : ι) (b : Ordinal.{u}), b < ord c → f i b < ord c
⊢ lift #ι < c
[PROOFSTEP]
rwa [lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
ho : lift (card o) < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal.{u}) (hi : i < o) (b : Ordinal.{max u v}), b < ord c → f i hi b < ord c
a : Ordinal.{max u v}
⊢ lift #(Quotient.out o).α < c
[PROOFSTEP]
rwa [mk_ordinal_out]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u} → Ordinal.{u}
c : Cardinal.{u}
hc : IsRegular c
ho : card o < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal.{u}) (hi : i < o) (b : Ordinal.{u}), b < ord c → f i hi b < ord c
a : Ordinal.{u}
⊢ lift (card o) < c
[PROOFSTEP]
rwa [lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
c : Cardinal.{u_2}
hc : IsRegular c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal.{u_2}), i < ord c → f i < ord c
a : Ordinal.{u_2}
⊢ ℵ₀ < Ordinal.cof (ord c)
[PROOFSTEP]
rw [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
c : Cardinal.{u_2}
hc : IsRegular c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal.{u_2}), i < ord c → f i < ord c
a : Ordinal.{u_2}
⊢ ℵ₀ < c
[PROOFSTEP]
exact lt_of_le_of_ne hc.1 hc'.symm
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
⊢ a < ord c → derivFamily f a < ord c
[PROOFSTEP]
have hω : ℵ₀ < c.ord.cof := by
  rw [hc.cof_eq]
  exact lt_of_le_of_ne hc.1 hc'.symm
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
⊢ ℵ₀ < Ordinal.cof (ord c)
[PROOFSTEP]
rw [hc.cof_eq]
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
⊢ ℵ₀ < c
[PROOFSTEP]
exact lt_of_le_of_ne hc.1 hc'.symm
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
hω : ℵ₀ < Ordinal.cof (ord c)
⊢ a < ord c → derivFamily f a < ord c
[PROOFSTEP]
induction a using limitRecOn with
| H₁ =>
  rw [derivFamily_zero]
  exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf
| H₂ b hb =>
  intro hb'
  rw [derivFamily_succ]
  exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf ((ord_isLimit hc.1).2 _ (hb ((lt_succ b).trans hb')))
| H₃ b hb H =>
  intro hb'
  rw [derivFamily_limit f hb]
  exact
    bsup_lt_ord_of_isRegular.{u, v} hc (ord_lt_ord.1 ((ord_card_le b).trans_lt hb')) fun o' ho' =>
      H o' ho' (ho'.trans hb')
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
a : Ordinal.{max u v}
hω : ℵ₀ < Ordinal.cof (ord c)
⊢ a < ord c → derivFamily f a < ord c
[PROOFSTEP]
induction a using limitRecOn with
| H₁ =>
  rw [derivFamily_zero]
  exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf
| H₂ b hb =>
  intro hb'
  rw [derivFamily_succ]
  exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf ((ord_isLimit hc.1).2 _ (hb ((lt_succ b).trans hb')))
| H₃ b hb H =>
  intro hb'
  rw [derivFamily_limit f hb]
  exact
    bsup_lt_ord_of_isRegular.{u, v} hc (ord_lt_ord.1 ((ord_card_le b).trans_lt hb')) fun o' ho' =>
      H o' ho' (ho'.trans hb')
[GOAL]
case H₁
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
⊢ 0 < ord c → derivFamily f 0 < ord c
[PROOFSTEP]

| H₁ =>
  rw [derivFamily_zero]
  exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf
[GOAL]
case H₁
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
⊢ 0 < ord c → derivFamily f 0 < ord c
[PROOFSTEP]
rw [derivFamily_zero]
[GOAL]
case H₁
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
⊢ 0 < ord c → nfpFamily f 0 < ord c
[PROOFSTEP]
exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
⊢ lift #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
case H₂
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : b < ord c → derivFamily f b < ord c
⊢ succ b < ord c → derivFamily f (succ b) < ord c
[PROOFSTEP]

| H₂ b hb =>
  intro hb'
  rw [derivFamily_succ]
  exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf ((ord_isLimit hc.1).2 _ (hb ((lt_succ b).trans hb')))
[GOAL]
case H₂
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : b < ord c → derivFamily f b < ord c
⊢ succ b < ord c → derivFamily f (succ b) < ord c
[PROOFSTEP]
intro hb'
[GOAL]
case H₂
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : b < ord c → derivFamily f b < ord c
hb' : succ b < ord c
⊢ derivFamily f (succ b) < ord c
[PROOFSTEP]
rw [derivFamily_succ]
[GOAL]
case H₂
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : b < ord c → derivFamily f b < ord c
hb' : succ b < ord c
⊢ nfpFamily f (succ (derivFamily f b)) < ord c
[PROOFSTEP]
exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf ((ord_isLimit hc.1).2 _ (hb ((lt_succ b).trans hb')))
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : b < ord c → derivFamily f b < ord c
hb' : succ b < ord c
⊢ lift #ι < Ordinal.cof (ord c)
[PROOFSTEP]
rwa [hc.cof_eq]
[GOAL]
case H₃
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : Ordinal.IsLimit b
H : ∀ (o' : Ordinal.{max u v}), o' < b → o' < ord c → derivFamily f o' < ord c
⊢ b < ord c → derivFamily f b < ord c
[PROOFSTEP]

| H₃ b hb H =>
  intro hb'
  rw [derivFamily_limit f hb]
  exact
    bsup_lt_ord_of_isRegular.{u, v} hc (ord_lt_ord.1 ((ord_card_le b).trans_lt hb')) fun o' ho' =>
      H o' ho' (ho'.trans hb')
[GOAL]
case H₃
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : Ordinal.IsLimit b
H : ∀ (o' : Ordinal.{max u v}), o' < b → o' < ord c → derivFamily f o' < ord c
⊢ b < ord c → derivFamily f b < ord c
[PROOFSTEP]
intro hb'
[GOAL]
case H₃
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : Ordinal.IsLimit b
H : ∀ (o' : Ordinal.{max u v}), o' < b → o' < ord c → derivFamily f o' < ord c
hb' : b < ord c
⊢ derivFamily f b < ord c
[PROOFSTEP]
rw [derivFamily_limit f hb]
[GOAL]
case H₃
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{max u v}), b < ord c → f i b < ord c
hω : ℵ₀ < Ordinal.cof (ord c)
b : Ordinal.{max u v}
hb : Ordinal.IsLimit b
H : ∀ (o' : Ordinal.{max u v}), o' < b → o' < ord c → derivFamily f o' < ord c
hb' : b < ord c
⊢ (bsup b fun a x => derivFamily f a) < ord c
[PROOFSTEP]
exact
  bsup_lt_ord_of_isRegular.{u, v} hc (ord_lt_ord.1 ((ord_card_le b).trans_lt hb')) fun o' ho' =>
    H o' ho' (ho'.trans hb')
[GOAL]
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u} → Ordinal.{u}
c : Cardinal.{u}
hc : IsRegular c
hι : #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι) (b : Ordinal.{u}), b < ord c → f i b < ord c
a : Ordinal.{u}
⊢ lift #ι < c
[PROOFSTEP]
rwa [lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : IsRegular c
hι : lift (card o) < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal.{u}) (hi : i < o) (b : Ordinal.{max u v}), b < ord c → f i hi b < ord c
a : Ordinal.{max u v}
⊢ lift #(Quotient.out o).α < c
[PROOFSTEP]
rwa [mk_ordinal_out]
[GOAL]
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u} → Ordinal.{u}
c : Cardinal.{u}
hc : IsRegular c
hι : card o < c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal.{u}) (hi : i < o) (b : Ordinal.{u}), b < ord c → f i hi b < ord c
a : Ordinal.{u}
⊢ lift (card o) < c
[PROOFSTEP]
rwa [lift_id]
[GOAL]
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
c : Cardinal.{u}
hc : IsRegular c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal.{u}), i < ord c → f i < ord c
a : Ordinal.{u}
⊢ lift #Unit < c
[PROOFSTEP]
simpa using Cardinal.one_lt_aleph0.trans (lt_of_le_of_ne hc.1 hc'.symm)
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ ℵ₀ < univ
[PROOFSTEP]
simpa using lift_lt_univ' ℵ₀
[GOAL]
α : Type u_1
r : α → α → Prop
⊢ univ ≤ Ordinal.cof (ord univ)
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
r : α → α → Prop
c : Cardinal.{max (u + 1) v}
h : c < univ
⊢ 2 ^ c < univ
[PROOFSTEP]
rcases lt_univ'.1 h with ⟨c, rfl⟩
[GOAL]
case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift c < univ
⊢ 2 ^ lift c < univ
[PROOFSTEP]
rw [← lift_two_power.{u, max (u + 1) v}]
[GOAL]
case intro
α : Type u_1
r : α → α → Prop
c : Cardinal.{u}
h : lift c < univ
⊢ lift (2 ^ c) < univ
[PROOFSTEP]
apply lift_lt_univ'
[GOAL]
α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
⊢ Quotient.mk isEquivalent α < Quotient.mk isEquivalent α ^ Ordinal.cof (ord (Quotient.mk isEquivalent α))
[PROOFSTEP]
rcases ord_eq α with ⟨r, wo, re⟩
[GOAL]
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
⊢ Quotient.mk isEquivalent α < Quotient.mk isEquivalent α ^ Ordinal.cof (ord (Quotient.mk isEquivalent α))
[PROOFSTEP]
skip
[GOAL]
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
⊢ Quotient.mk isEquivalent α < Quotient.mk isEquivalent α ^ Ordinal.cof (ord (Quotient.mk isEquivalent α))
[PROOFSTEP]
have := ord_isLimit h
[GOAL]
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (ord (Quotient.mk isEquivalent α))
⊢ Quotient.mk isEquivalent α < Quotient.mk isEquivalent α ^ Ordinal.cof (ord (Quotient.mk isEquivalent α))
[PROOFSTEP]
rw [mk'_def, re] at this ⊢
[GOAL]
case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
⊢ #α < #α ^ Ordinal.cof (type r)
[PROOFSTEP]
rcases cof_eq' r this with ⟨S, H, Se⟩
[GOAL]
case intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
⊢ #α < #α ^ Ordinal.cof (type r)
[PROOFSTEP]
have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
[GOAL]
case intro.intro.intro.intro.refine_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
this : (sum fun a => #{ x // r x ↑a }) < prod fun x => #α
⊢ #α < #α ^ Ordinal.cof (type r)
[PROOFSTEP]
simp only [Cardinal.prod_const, Cardinal.lift_id, ← Se, ← mk_sigma, power_def] at this ⊢
[GOAL]
case intro.intro.intro.intro.refine_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
this : #((i : ↑S) × { x // r x ↑i }) < #(↑S → α)
⊢ #α < #(↑S → α)
[PROOFSTEP]
refine' lt_of_le_of_lt _ this
[GOAL]
case intro.intro.intro.intro.refine_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
this : #((i : ↑S) × { x // r x ↑i }) < #(↑S → α)
⊢ #α ≤ #((i : ↑S) × { x // r x ↑i })
[PROOFSTEP]
refine' ⟨Embedding.ofSurjective _ _⟩
[GOAL]
case intro.intro.intro.intro.refine_2.refine'_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
this : #((i : ↑S) × { x // r x ↑i }) < #(↑S → α)
⊢ (i : ↑S) × { x // r x ↑i } → α
[PROOFSTEP]
exact fun x => x.2.1
[GOAL]
case intro.intro.intro.intro.refine_2.refine'_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
this : #((i : ↑S) × { x // r x ↑i }) < #(↑S → α)
⊢ Surjective fun x => ↑x.snd
[PROOFSTEP]
exact fun a =>
  let ⟨b, h, ab⟩ := H a
  ⟨⟨⟨_, h⟩, _, ab⟩, rfl⟩
[GOAL]
case intro.intro.intro.intro.refine_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
i : ↑S
⊢ (fun a => #{ x // r x ↑a }) i < (fun x => #α) i
[PROOFSTEP]
have := typein_lt_type r i
[GOAL]
case intro.intro.intro.intro.refine_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ Quotient.mk isEquivalent α
r : α → α → Prop
wo : IsWellOrder α r
re : ord #α = type r
this✝ : Ordinal.IsLimit (type r)
S : Set α
H : ∀ (a : α), ∃ b, b ∈ S ∧ r a b
Se : #↑S = Ordinal.cof (type r)
i : ↑S
this : typein r ↑i < type r
⊢ (fun a => #{ x // r x ↑a }) i < (fun x => #α) i
[PROOFSTEP]
rwa [← re, lt_ord] at this
[GOAL]
α : Type u_1
r : α → α → Prop
a b : Cardinal.{u_2}
ha : ℵ₀ ≤ a
b1 : 1 < b
⊢ a < Ordinal.cof (ord (b ^ a))
[PROOFSTEP]
have b0 : b ≠ 0 := (zero_lt_one.trans b1).ne'
[GOAL]
α : Type u_1
r : α → α → Prop
a b : Cardinal.{u_2}
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ a < Ordinal.cof (ord (b ^ a))
[PROOFSTEP]
apply lt_imp_lt_of_le_imp_le (power_le_power_left <| power_ne_zero a b0)
[GOAL]
α : Type u_1
r : α → α → Prop
a b : Cardinal.{u_2}
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ (b ^ a) ^ a < (b ^ a) ^ Ordinal.cof (ord (b ^ a))
[PROOFSTEP]
rw [← power_mul, mul_eq_self ha]
[GOAL]
α : Type u_1
r : α → α → Prop
a b : Cardinal.{u_2}
ha : ℵ₀ ≤ a
b1 : 1 < b
b0 : b ≠ 0
⊢ b ^ a < (b ^ a) ^ Ordinal.cof (ord (b ^ a))
[PROOFSTEP]
exact lt_power_cof (ha.trans <| (cantor' _ b1).le)