l3lab/ntp-mathlib huggingface dataset:
theorem le_cof_iff_lsub {o : Ordinal} {a : Cardinal} :
    a ≤ cof o ↔ ∀ {ι} (f : ι → Ordinal), lsub.{u, u} f = o → a ≤ #ι := by
  

Proof state:
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
a : Cardinal.{u}
⊢ a ≤ cof o ↔ ∀ {ι : Type u} (f : ι → Ordinal.{u}), lsub f = o → a ≤ #ι

Next tactic:
rw [cof_eq_sInf_lsub]
theorem le_cof_iff_lsub {o : Ordinal} {a : Cardinal} :
    a ≤ cof o ↔ ∀ {ι} (f : ι → Ordinal), lsub.{u, u} f = o → a ≤ #ι := by
  rw [cof_eq_sInf_lsub]
  

Proof state:
α : 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 ≤ #ι

Next tactic:
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⟩
theorem le_cof_iff_lsub {o : Ordinal} {a : Cardinal} :
    a ≤ cof o ↔ ∀ {ι} (f : ι → Ordinal), lsub.{u, u} f = o → a ≤ #ι := by
  rw [cof_eq_sInf_lsub]
  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
        

Proof state:
α : 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

Next tactic:
rw [← hb]
theorem le_cof_iff_lsub {o : Ordinal} {a : Cardinal} :
    a ≤ cof o ↔ ∀ {ι} (f : ι → Ordinal), lsub.{u, u} f = o → a ≤ #ι := by
  rw [cof_eq_sInf_lsub]
  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]
        

Proof state:
α : 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 ≤ #ι

Next tactic:
exact H _ hf
theorem lsub_lt_ord_lift {ι} {f : ι → Ordinal} {c : Ordinal}
    (hι : Cardinal.lift.{v, u} #ι < c.cof)
    (hf : ∀ i, f i < c) : lsub.{u, v} f < c :=
  lt_of_le_of_ne (lsub_le.{v, u} hf) fun h => by
    

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
c : Ordinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < cof c
hf : ∀ (i : ι), f i < c
h : lsub f = c
⊢ False

Next tactic:
subst h
theorem lsub_lt_ord_lift {ι} {f : ι → Ordinal} {c : Ordinal}
    (hι : Cardinal.lift.{v, u} #ι < c.cof)
    (hf : ∀ i, f i < c) : lsub.{u, v} f < c :=
  lt_of_le_of_ne (lsub_le.{v, u} hf) fun h => by
    subst h
    

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < cof (lsub f)
hf : ∀ (i : ι), f i < lsub f
⊢ False

Next tactic:
exact (cof_lsub_le_lift.{u, v} f).not_lt hι
theorem lsub_lt_ord {ι} {f : ι → Ordinal} {c : Ordinal} (hι : #ι < c.cof) :
    (∀ i, f i < c) → lsub.{u, u} f < c :=
  lsub_lt_ord_lift (by 

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
c : Ordinal.{u}
hι : #ι < cof c
⊢ Cardinal.lift.{u, u} #ι < cof c

Next tactic:
rwa [(#ι).lift_id]
theorem cof_sup_le_lift {ι} {f : ι → Ordinal} (H : ∀ i, f i < sup.{u, v} f) :
    cof (sup.{u, v} f) ≤ Cardinal.lift.{v, u} #ι := by
  

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v}
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ Cardinal.lift.{v, u} #ι

Next tactic:
rw [← sup_eq_lsub_iff_lt_sup.{u, v}] at H
theorem cof_sup_le_lift {ι} {f : ι → Ordinal} (H : ∀ i, f i < sup.{u, v} f) :
    cof (sup.{u, v} f) ≤ Cardinal.lift.{v, u} #ι := by
  rw [← sup_eq_lsub_iff_lt_sup.{u, v}] at H
  

Proof state:
α : 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.{v, u} #ι

Next tactic:
rw [H]
theorem cof_sup_le_lift {ι} {f : ι → Ordinal} (H : ∀ i, f i < sup.{u, v} f) :
    cof (sup.{u, v} f) ≤ Cardinal.lift.{v, u} #ι := by
  rw [← sup_eq_lsub_iff_lt_sup.{u, v}] at H
  rw [H]
  

Proof state:
α : 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.{v, u} #ι

Next tactic:
exact cof_lsub_le_lift f
theorem cof_sup_le {ι} {f : ι → Ordinal} (H : ∀ i, f i < sup.{u, u} f) :
    cof (sup.{u, u} f) ≤ #ι := by
  

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ #ι

Next tactic:
rw [← (#ι).lift_id]
theorem cof_sup_le {ι} {f : ι → Ordinal} (H : ∀ i, f i < sup.{u, u} f) :
    cof (sup.{u, u} f) ≤ #ι := by
  rw [← (#ι).lift_id]
  

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
H : ∀ (i : ι), f i < sup f
⊢ cof (sup f) ≤ Cardinal.lift.{u, u} #ι

Next tactic:
exact cof_sup_le_lift H
theorem sup_lt_ord {ι} {f : ι → Ordinal} {c : Ordinal} (hι : #ι < c.cof) :
    (∀ i, f i < c) → sup.{u, u} f < c :=
  sup_lt_ord_lift (by 

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u}
c : Ordinal.{u}
hι : #ι < cof c
⊢ Cardinal.lift.{u, u} #ι < cof c

Next tactic:
rwa [(#ι).lift_id]
theorem iSup_lt_lift {ι} {f : ι → Cardinal} {c : Cardinal}
    (hι : Cardinal.lift.{v, u} #ι < c.ord.cof)
    (hf : ∀ i, f i < c) : iSup.{max u v + 1, u + 1} f < c := by
  

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < cof (ord c)
hf : ∀ (i : ι), f i < c
⊢ iSup f < c

Next tactic:
rw [← ord_lt_ord, iSup_ord (Cardinal.bddAbove_range.{u, v} _)]
theorem iSup_lt_lift {ι} {f : ι → Cardinal} {c : Cardinal}
    (hι : Cardinal.lift.{v, u} #ι < c.ord.cof)
    (hf : ∀ i, f i < c) : iSup.{max u v + 1, u + 1} f < c := by
  rw [← ord_lt_ord, iSup_ord (Cardinal.bddAbove_range.{u, v} _)]
  

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < cof (ord c)
hf : ∀ (i : ι), f i < c
⊢ ⨆ i, ord (f i) < ord c

Next tactic:
refine' sup_lt_ord_lift hι fun i => _
theorem iSup_lt_lift {ι} {f : ι → Cardinal} {c : Cardinal}
    (hι : Cardinal.lift.{v, u} #ι < c.ord.cof)
    (hf : ∀ i, f i < c) : iSup.{max u v + 1, u + 1} f < c := by
  rw [← ord_lt_ord, iSup_ord (Cardinal.bddAbove_range.{u, v} _)]
  refine' sup_lt_ord_lift hι fun i => _
  

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < cof (ord c)
hf : ∀ (i : ι), f i < c
i : ι
⊢ ord (f i) < ord c

Next tactic:
rw [ord_lt_ord]
theorem iSup_lt_lift {ι} {f : ι → Cardinal} {c : Cardinal}
    (hι : Cardinal.lift.{v, u} #ι < c.ord.cof)
    (hf : ∀ i, f i < c) : iSup.{max u v + 1, u + 1} f < c := by
  rw [← ord_lt_ord, iSup_ord (Cardinal.bddAbove_range.{u, v} _)]
  refine' sup_lt_ord_lift hι fun i => _
  rw [ord_lt_ord]
  

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < cof (ord c)
hf : ∀ (i : ι), f i < c
i : ι
⊢ f i < c

Next tactic:
apply hf
theorem iSup_lt {ι} {f : ι → Cardinal} {c : Cardinal} (hι : #ι < c.ord.cof) :
    (∀ i, f i < c) → iSup f < c :=
  iSup_lt_lift (by 

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u_2
f : ι → Cardinal.{u_2}
c : Cardinal.{u_2}
hι : #ι < cof (ord c)
⊢ Cardinal.lift.{?u.30057, u_2} #ι < cof (ord c)

Next tactic:
rwa [(#ι).lift_id]
theorem nfpFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} #ι < cof c) (hf : ∀ (i), ∀ b < c, f i b < c) {a} (ha : a < c) :
    nfpFamily.{u, v} f a < c := by
  

Proof state:
α : 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.{v, u} #ι < cof c
hf : ∀ (i : ι), ∀ b < c, f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ nfpFamily f a < c

Next tactic:
refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
theorem nfpFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} #ι < cof c) (hf : ∀ (i), ∀ b < c, f i b < c) {a} (ha : a < c) :
    nfpFamily.{u, v} f a < c := by
  refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
  · 

Proof state:
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.{v, u} #ι < cof c
hf : ∀ (i : ι), ∀ b < c, f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ Cardinal.lift.{v, u} (max ℵ₀ #ι) < cof c

Next tactic:
rw [lift_max]
theorem nfpFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} #ι < cof c) (hf : ∀ (i), ∀ b < c, f i b < c) {a} (ha : a < c) :
    nfpFamily.{u, v} f a < c := by
  refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
  · rw [lift_max]
    

Proof state:
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.{v, u} #ι < cof c
hf : ∀ (i : ι), ∀ b < c, f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ max (Cardinal.lift.{v, u} ℵ₀) (Cardinal.lift.{v, u} #ι) < cof c

Next tactic:
apply max_lt _ hc'
theorem nfpFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} #ι < cof c) (hf : ∀ (i), ∀ b < c, f i b < c) {a} (ha : a < c) :
    nfpFamily.{u, v} f a < c := by
  refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
  · rw [lift_max]
    apply max_lt _ hc'
    

Proof state:
α : 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.{v, u} #ι < cof c
hf : ∀ (i : ι), ∀ b < c, f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ Cardinal.lift.{v, u} ℵ₀ < cof c

Next tactic:
rwa [Cardinal.lift_aleph0]
theorem nfpFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} #ι < cof c) (hf : ∀ (i), ∀ b < c, f i b < c) {a} (ha : a < c) :
    nfpFamily.{u, v} f a < c := by
  refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
  · rw [lift_max]
    apply max_lt _ hc'
    rwa [Cardinal.lift_aleph0]
  · 

Proof state:
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.{v, u} #ι < cof c
hf : ∀ (i : ι), ∀ b < c, f i b < c
a : Ordinal.{max u v}
ha : a < c
l : List ι
⊢ List.foldr f a l < c

Next tactic:
induction' l with i l H
theorem nfpFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} #ι < cof c) (hf : ∀ (i), ∀ b < c, f i b < c) {a} (ha : a < c) :
    nfpFamily.{u, v} f a < c := by
  refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
  · rw [lift_max]
    apply max_lt _ hc'
    rwa [Cardinal.lift_aleph0]
  · induction' l with i l H
    · 

Proof state:
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.{v, u} #ι < cof c
hf : ∀ (i : ι), ∀ b < c, f i b < c
a : Ordinal.{max u v}
ha : a < c
⊢ List.foldr f a [] < c

Next tactic:
exact ha
theorem nfpFamily_lt_ord_lift {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} #ι < cof c) (hf : ∀ (i), ∀ b < c, f i b < c) {a} (ha : a < c) :
    nfpFamily.{u, v} f a < c := by
  refine' sup_lt_ord_lift ((Cardinal.lift_le.2 (mk_list_le_max ι)).trans_lt _) fun l => _
  · rw [lift_max]
    apply max_lt _ hc'
    rwa [Cardinal.lift_aleph0]
  · induction' l with i l H
    · exact ha
    · 

Proof state:
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.{v, u} #ι < cof c
hf : ∀ (i : ι), ∀ 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

Next tactic:
exact hf _ _ H
theorem nfpFamily_lt_ord {ι} {f : ι → Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c) (hc' : #ι < cof c)
    (hf : ∀ (i), ∀ b < c, f i b < c) {a} : a < c → nfpFamily.{u, u} f a < c :=
  nfpFamily_lt_ord_lift hc (by 

Proof state:
α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{u} → Ordinal.{u}
c : Ordinal.{u}
hc : ℵ₀ < cof c
hc' : #ι < cof c
hf : ∀ (i : ι), ∀ b < c, f i b < c
a : Ordinal.{u}
⊢ Cardinal.lift.{u, u} #ι < cof c

Next tactic:
rwa [(#ι).lift_id]
theorem nfpBFamily_lt_ord_lift {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : Cardinal.lift.{v, u} o.card < cof c) (hf : ∀ (i hi), ∀ b < c, f i hi b < c) {a} :
    a < c → nfpBFamily.{u, v} o f a < c :=
  nfpFamily_lt_ord_lift hc (by 

Proof state:
α : 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.{v, u} (card o) < cof c
hf : ∀ (i : Ordinal.{u}) (hi : i < o), ∀ b < c, f i hi b < c
a : Ordinal.{max u v}
⊢ Cardinal.lift.{v, u} #(Quotient.out o).α < cof c

Next tactic:
rwa [mk_ordinal_out]
theorem nfpBFamily_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c)
    (hc' : o.card < cof c) (hf : ∀ (i hi), ∀ b < c, f i hi b < c) {a} :
    a < c → nfpBFamily.{u, u} o f a < c :=
  nfpBFamily_lt_ord_lift hc (by 

Proof state:
α : 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 < c, f i hi b < c
a : Ordinal.{u}
⊢ Cardinal.lift.{u, u} (card o) < cof c

Next tactic:
rwa [o.card.lift_id]
theorem nfp_lt_ord {f : Ordinal → Ordinal} {c} (hc : ℵ₀ < cof c) (hf : ∀ i < c, f i < c) {a} :
    a < c → nfp f a < c :=
  nfpFamily_lt_ord_lift hc (by 

Proof state:
α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
c : Ordinal.{u_2}
hc : ℵ₀ < cof c
hf : ∀ i < c, f i < c
a : Ordinal.{u_2}
⊢ Cardinal.lift.{u_2, 0} #Unit < cof c

Next tactic:
simpa using Cardinal.one_lt_aleph0.trans hc
theorem exists_blsub_cof (o : Ordinal) :
    ∃ f : ∀ a < (cof o).ord, Ordinal, blsub.{u, u} _ f = o := by
  

Proof state:
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ ∃ f, blsub (ord (cof o)) f = o

Next tactic:
rcases exists_lsub_cof o with ⟨ι, f, hf, hι⟩
theorem exists_blsub_cof (o : Ordinal) :
    ∃ f : ∀ a < (cof o).ord, Ordinal, blsub.{u, u} _ f = o := by
  rcases exists_lsub_cof o with ⟨ι, f, hf, hι⟩
  

Proof state:
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

Next tactic:
rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
theorem exists_blsub_cof (o : Ordinal) :
    ∃ f : ∀ a < (cof o).ord, Ordinal, blsub.{u, u} _ f = o := by
  rcases exists_lsub_cof o with ⟨ι, f, hf, hι⟩
  rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
  

Proof state:
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

Next tactic:
rw [← @blsub_eq_lsub' ι r hr] at hf
theorem exists_blsub_cof (o : Ordinal) :
    ∃ f : ∀ a < (cof o).ord, Ordinal, blsub.{u, u} _ f = o := by
  rcases exists_lsub_cof o with ⟨ι, f, hf, hι⟩
  rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
  rw [← @blsub_eq_lsub' ι r hr] at hf
  

Proof state:
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

Next tactic:
rw [← hι, hι']
theorem exists_blsub_cof (o : Ordinal) :
    ∃ f : ∀ a < (cof o).ord, Ordinal, blsub.{u, u} _ f = o := by
  rcases exists_lsub_cof o with ⟨ι, f, hf, hι⟩
  rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
  rw [← @blsub_eq_lsub' ι r hr] at hf
  rw [← hι, hι']
  

Proof state:
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

Next tactic:
exact ⟨_, hf⟩
theorem le_cof_iff_blsub {b : Ordinal} {a : Cardinal} :
    a ≤ cof b ↔ ∀ {o} (f : ∀ a < o, Ordinal), blsub.{u, u} o f = b → a ≤ o.card :=
  le_cof_iff_lsub.trans
    ⟨fun H o f hf => by 

Proof state:
α : 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

Next tactic:
simpa using H _ hf
theorem le_cof_iff_blsub {b : Ordinal} {a : Cardinal} :
    a ≤ cof b ↔ ∀ {o} (f : ∀ a < o, Ordinal), blsub.{u, u} o f = b → a ≤ o.card :=
  le_cof_iff_lsub.trans
    ⟨fun H o f hf => by simpa using H _ hf, fun H ι f hf => by
      

Proof state:
α : 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 ≤ #ι

Next tactic:
rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
theorem le_cof_iff_blsub {b : Ordinal} {a : Cardinal} :
    a ≤ cof b ↔ ∀ {o} (f : ∀ a < o, Ordinal), blsub.{u, u} o f = b → a ≤ o.card :=
  le_cof_iff_lsub.trans
    ⟨fun H o f hf => by simpa using H _ hf, fun H ι f hf => by
      rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
      

Proof state:
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 ≤ #ι

Next tactic:
rw [← @blsub_eq_lsub' ι r hr] at hf
theorem le_cof_iff_blsub {b : Ordinal} {a : Cardinal} :
    a ≤ cof b ↔ ∀ {o} (f : ∀ a < o, Ordinal), blsub.{u, u} o f = b → a ≤ o.card :=
  le_cof_iff_lsub.trans
    ⟨fun H o f hf => by simpa using H _ hf, fun H ι f hf => by
      rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
      rw [← @blsub_eq_lsub' ι r hr] at hf
      

Proof state:
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 ≤ #ι

Next tactic:
simpa using H _ hf
theorem cof_blsub_le_lift {o} (f : ∀ a < o, Ordinal) :
    cof (blsub.{u, v} o f) ≤ Cardinal.lift.{v, u} o.card := by
  

Proof state:
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ cof (blsub o f) ≤ Cardinal.lift.{v, u} (card o)

Next tactic:
rw [← mk_ordinal_out o]
theorem cof_blsub_le_lift {o} (f : ∀ a < o, Ordinal) :
    cof (blsub.{u, v} o f) ≤ Cardinal.lift.{v, u} o.card := by
  rw [← mk_ordinal_out o]
  

Proof state:
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
⊢ cof (blsub o f) ≤ Cardinal.lift.{v, u} #(Quotient.out o).α

Next tactic:
exact cof_lsub_le_lift _
theorem cof_blsub_le {o} (f : ∀ a < o, Ordinal) : cof (blsub.{u, u} o f) ≤ o.card := by
  

Proof state:
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ cof (blsub o f) ≤ card o

Next tactic:
rw [← o.card.lift_id]
theorem cof_blsub_le {o} (f : ∀ a < o, Ordinal) : cof (blsub.{u, u} o f) ≤ o.card := by
  rw [← o.card.lift_id]
  

Proof state:
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ cof (blsub o f) ≤ Cardinal.lift.{u, u} (card o)

Next tactic:
exact cof_blsub_le_lift f
theorem blsub_lt_ord_lift {o : Ordinal.{u}} {f : ∀ a < o, Ordinal} {c : Ordinal}
    (ho : Cardinal.lift.{v, u} o.card < c.cof) (hf : ∀ i hi, f i hi < c) : blsub.{u, v} o f < c :=
  lt_of_le_of_ne (blsub_le hf) fun h =>
    ho.not_le (by 

Proof state:
α : 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.{v, u} (card o) < cof c
hf : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi < c
h : blsub o f = c
⊢ cof c ≤ Cardinal.lift.{v, u} (card o)

Next tactic:
simpa [← iSup_ord, hf, h] using cof_blsub_le_lift.{u, v} f
theorem blsub_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal} {c : Ordinal} (ho : o.card < c.cof)
    (hf : ∀ i hi, f i hi < c) : blsub.{u, u} o f < c :=
  blsub_lt_ord_lift (by 

Proof state:
α : 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.{u, u} (card o) < cof c

Next tactic:
rwa [o.card.lift_id]
theorem cof_bsup_le_lift {o : Ordinal} {f : ∀ a < o, Ordinal} (H : ∀ i h, f i h < bsup.{u, v} o f) :
    cof (bsup.{u, v} o f) ≤ Cardinal.lift.{v, u} o.card := by
  

Proof state:
α : 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.{v, u} (card o)

Next tactic:
rw [← bsup_eq_blsub_iff_lt_bsup.{u, v}] at H
theorem cof_bsup_le_lift {o : Ordinal} {f : ∀ a < o, Ordinal} (H : ∀ i h, f i h < bsup.{u, v} o f) :
    cof (bsup.{u, v} o f) ≤ Cardinal.lift.{v, u} o.card := by
  rw [← bsup_eq_blsub_iff_lt_bsup.{u, v}] at H
  

Proof state:
α : 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.{v, u} (card o)

Next tactic:
rw [H]
theorem cof_bsup_le_lift {o : Ordinal} {f : ∀ a < o, Ordinal} (H : ∀ i h, f i h < bsup.{u, v} o f) :
    cof (bsup.{u, v} o f) ≤ Cardinal.lift.{v, u} o.card := by
  rw [← bsup_eq_blsub_iff_lt_bsup.{u, v}] at H
  rw [H]
  

Proof state:
α : 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.{v, u} (card o)

Next tactic:
exact cof_blsub_le_lift.{u, v} f
theorem cof_bsup_le {o : Ordinal} {f : ∀ a < o, Ordinal} :
    (∀ i h, f i h < bsup.{u, u} o f) → cof (bsup.{u, u} o f) ≤ o.card := by
  

Proof state:
α : 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

Next tactic:
rw [← o.card.lift_id]
theorem cof_bsup_le {o : Ordinal} {f : ∀ a < o, Ordinal} :
    (∀ i h, f i h < bsup.{u, u} o f) → cof (bsup.{u, u} o f) ≤ o.card := by
  rw [← o.card.lift_id]
  

Proof state:
α : 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.{u, u} (card o)

Next tactic:
exact cof_bsup_le_lift
theorem bsup_lt_ord {o : Ordinal} {f : ∀ a < o, Ordinal} {c : Ordinal} (ho : o.card < c.cof) :
    (∀ i hi, f i hi < c) → bsup.{u, u} o f < c :=
  bsup_lt_ord_lift (by 

Proof state:
α : 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.{u, u} (card o) < cof c

Next tactic:
rwa [o.card.lift_id]
@[simp]
theorem cof_zero : cof 0 = 0 := by
  

Proof state:
α : Type u_1
r : α → α → Prop
⊢ cof 0 = 0

Next tactic:
refine LE.le.antisymm  ?_ (Cardinal.zero_le _)
@[simp]
theorem cof_zero : cof 0 = 0 := by
  refine LE.le.antisymm  ?_ (Cardinal.zero_le _)
  

Proof state:
α : Type u_1
r : α → α → Prop
⊢ cof 0 ≤ 0

Next tactic:
rw [← card_zero]
@[simp]
theorem cof_zero : cof 0 = 0 := by
  refine LE.le.antisymm  ?_ (Cardinal.zero_le _)
  rw [← card_zero]
  

Proof state:
α : Type u_1
r : α → α → Prop
⊢ cof 0 ≤ card 0

Next tactic:
exact cof_le_card 0