Theorem: Profinite.NobelingProof.Products.limitOrdinal
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: refine ⟨fun h ↦ ?_, fun ⟨o', ⟨ho', hl⟩⟩ ↦ isGood_mono C (le_of_lt ho') hl⟩
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
⊢ isGood (π C fun x => ord I x < o) l ↔ ∃ o' < o, isGood (π C fun x => ord I x < o') l
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
⊢ ∃ o' < o, isGood (π C fun x => ord I x < o') l

tactic: use Finset.sup l.val.toFinset (fun a ↦ Order.succ (ord I a))
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
⊢ ∃ o' < o, isGood (π C fun x => ord I x < o') l
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
⊢ ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o ∧
    isGood (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l

tactic: have ha : ⊥ < o := by rw [Ordinal.bot_eq_zero, Ordinal.pos_iff_ne_zero]; exact ho.1
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
⊢ ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o ∧
    isGood (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
⊢ ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o ∧
    isGood (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l

tactic: refine ⟨hslt, fun he ↦ h ?_⟩
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
⊢ ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o ∧
    isGood (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
⊢ eval (π C fun x => ord I x < o) l ∈ Submodule.span ℤ (eval (π C fun x => ord I x < o) '' {m | m < l})

tactic: have hlt : ∀ i ∈ l.val, ord I i < Finset.sup l.val.toFinset (fun a ↦ Order.succ (ord I a)) := by
  intro i hi
  simp only [Finset.lt_sup_iff, List.mem_toFinset, Order.lt_succ_iff]
  exact ⟨i, hi, le_rfl⟩
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
⊢ eval (π C fun x => ord I x < o) l ∈ Submodule.span ℤ (eval (π C fun x => ord I x < o) '' {m | m < l})
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
hlt : ∀ i ∈ ↑l, ord I i < (↑l).toFinset.sup fun a => Order.succ (ord I a)
⊢ eval (π C fun x => ord I x < o) l ∈ Submodule.span ℤ (eval (π C fun x => ord I x < o) '' {m | m < l})

tactic: rwa [eval_πs_image' C (le_of_lt hslt) hlt, ← eval_πs' C (le_of_lt hslt) hlt,
  Submodule.apply_mem_span_image_iff_mem_span (injective_πs' C _)]
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
hlt : ∀ i ∈ ↑l, ord I i < (↑l).toFinset.sup fun a => Order.succ (ord I a)
⊢ eval (π C fun x => ord I x < o) l ∈ Submodule.span ℤ (eval (π C fun x => ord I x < o) '' {m | m < l})
state_after: no goals

tactic: rw [Ordinal.bot_eq_zero, Ordinal.pos_iff_ne_zero]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
⊢ ⊥ < o
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
⊢ o ≠ 0

tactic: exact ho.1
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
⊢ o ≠ 0
state_after: no goals

tactic: simp only [Finset.sup_lt_iff ha, List.mem_toFinset]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
⊢ ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
⊢ ∀ b ∈ ↑l, Order.succ (ord I b) < o

tactic: intro i hi
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
⊢ ∀ i ∈ ↑l, ord I i < (↑l).toFinset.sup fun a => Order.succ (ord I a)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
i : I
hi : i ∈ ↑l
⊢ ord I i < (↑l).toFinset.sup fun a => Order.succ (ord I a)

tactic: simp only [Finset.lt_sup_iff, List.mem_toFinset, Order.lt_succ_iff]
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
i : I
hi : i ∈ ↑l
⊢ ord I i < (↑l).toFinset.sup fun a => Order.succ (ord I a)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
i : I
hi : i ∈ ↑l
⊢ ∃ b ∈ ↑l, ord I i ≤ ord I b

tactic: exact ⟨i, hi, le_rfl⟩
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
l : Products I
h : isGood (π C fun x => ord I x < o) l
ha : ⊥ < o
hslt : ((↑l).toFinset.sup fun a => Order.succ (ord I a)) < o
he :
  eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) l ∈
    Submodule.span ℤ (eval (π C fun x => ord I x < (↑l).toFinset.sup fun a => Order.succ (ord I a)) '' {m | m < l})
i : I
hi : i ∈ ↑l
⊢ ∃ b ∈ ↑l, ord I i ≤ ord I b
state_after: no goals