Theorem: Ordinal.IsNormal.isFundamentalSequence
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: refine ⟨?_, @fun i j _ _ h => hf.strictMono (hg.2.1 _ _ h), ?_⟩
state_before: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
⊢ (f a).IsFundamentalSequence o fun b hb => f (g b hb)
state_after: case refine_1
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
⊢ o ≤ (f a).cof.ord

case refine_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
⊢ (o.blsub fun b hb => f (g b hb)) = f a

tactic: rcases exists_lsub_cof (f a) with ⟨ι, f', hf', hι⟩
state_before: case refine_1
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
⊢ o ≤ (f a).cof.ord
state_after: case refine_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
⊢ o ≤ (f a).cof.ord

tactic: rw [← hg.cof_eq, ord_le_ord, ← hι]
state_before: case refine_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
⊢ o ≤ (f a).cof.ord
state_after: case refine_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
⊢ a.cof ≤ #ι

tactic: suffices (lsub.{u, u} fun i => sInf { b : Ordinal | f' i ≤ f b }) = a by
  rw [← this]
  apply cof_lsub_le
state_before: case refine_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
⊢ a.cof ≤ #ι
state_after: case refine_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
⊢ (lsub fun i => sInf {b | f' i ≤ f b}) = a

tactic: 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
state_before: case refine_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
⊢ (lsub fun i => sInf {b | f' i ≤ f b}) = a
state_after: case refine_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ b < a, f' i ≤ f b
⊢ (lsub fun i => sInf {b | f' i ≤ f b}) = a

tactic: refine (lsub_le fun i => ?_).antisymm (le_of_forall_lt fun b hb => ?_)
state_before: case refine_1.intro.intro.intro
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ b < a, f' i ≤ f b
⊢ (lsub fun i => sInf {b | f' i ≤ f b}) = a
state_after: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ b < a, f' i ≤ f b
i : ι
⊢ sInf {b | f' i ≤ f b} < a

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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ b < a, f' i ≤ f b
b : Ordinal.{u}
hb : b < a
⊢ b < lsub fun i => sInf {b | f' i ≤ f b}

tactic: rw [← this]
state_before: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
this : (lsub fun i => sInf {b | f' i ≤ f b}) = a
⊢ a.cof ≤ #ι
state_after: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
this : (lsub fun i => sInf {b | f' i ≤ f b}) = a
⊢ (lsub fun i => sInf {b | f' i ≤ f b}).cof ≤ #ι

tactic: apply cof_lsub_le
state_before: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
this : (lsub fun i => sInf {b | f' i ≤ f b}) = a
⊢ (lsub fun i => sInf {b | f' i ≤ f b}).cof ≤ #ι
state_after: no goals

tactic: have := lt_lsub.{u, u} f' i
state_before: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
i : ι
⊢ ∃ b < a, f' i ≤ f b
state_after: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
i : ι
this : f' i < lsub f'
⊢ ∃ b < a, f' i ≤ f b

tactic: rw [hf', ← IsNormal.blsub_eq.{u, u} hf ha, lt_blsub_iff] at this
state_before: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
i : ι
this : f' i < lsub f'
⊢ ∃ b < a, f' i ≤ f b
state_after: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
i : ι
this : ∃ i_1, ∃ (_ : i_1 < a), f' i ≤ f i_1
⊢ ∃ b < a, f' i ≤ f b

tactic: simpa using this
state_before: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
i : ι
this : ∃ i_1, ∃ (_ : i_1 < a), f' i ≤ f i_1
⊢ ∃ b < a, f' i ≤ f b
state_after: no goals

tactic: rcases H i with ⟨b, hb, hb'⟩
state_before: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ b < a, f' i ≤ f b
i : ι
⊢ sInf {b | f' i ≤ f b} < a
state_after: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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

tactic: exact lt_of_le_of_lt (csInf_le' hb') hb
state_before: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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
state_after: no goals

tactic: have := hf.strictMono hb
state_before: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ b < a, f' i ≤ f b
b : Ordinal.{u}
hb : b < a
⊢ b < lsub fun i => sInf {b | f' i ≤ f b}
state_after: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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}

tactic: rw [← hf', lt_lsub_iff] at this
state_before: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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}
state_after: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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}

tactic: cases' this with i hi
state_before: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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}
state_after: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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}

tactic: rcases H i with ⟨b, _, hb⟩
state_before: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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}
state_after: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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}

tactic: 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)
state_before: 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 : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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}
state_after: no goals

tactic: exact hb
state_before: α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
ι : Type u
f' : ι → Ordinal.{u}
hf' : lsub f' = f a
hι : #ι = (f a).cof
H : ∀ (i : ι), ∃ 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₁)
          ⋯ (f c))
      ⋯ (f' i)
state_after: no goals

tactic: rw [@blsub_comp.{u, u, u} a _ (fun b _ => f b) (@fun i j _ _ h => hf.strictMono.monotone h) g
    hg.2.2]
state_before: case refine_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
⊢ (o.blsub fun b hb => f (g b hb)) = f a
state_after: case refine_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
⊢ (a.blsub fun b x => f b) = f a

tactic: exact IsNormal.blsub_eq.{u, u} hf ha
state_before: case refine_2
α : Type u_1
r : α → α → Prop
f : Ordinal.{u} → Ordinal.{u}
hf : IsNormal f
a o : Ordinal.{u}
ha : a.IsLimit
g : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hg : a.IsFundamentalSequence o g
⊢ (a.blsub fun b x => f b) = f a
state_after: no goals