File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

full_name: Ordinal.lift_add
code: @[simp]
theorem lift_add (a b : Ordinal.{v}) : lift.{u} (a + b) = lift.{u} a + lift.{u} b 
goal: Ordinal.lift.{u, v} (a + b) = Ordinal.lift.{u, v} a + Ordinal.lift.{u, v} b

full_name: Ordinal.lift_succ
code: @[simp]
theorem lift_succ (a : Ordinal.{v}) : lift.{u} (succ a) = succ (lift.{u} a) 
goal: Ordinal.lift.{u, v} (Order.succ a) = Order.succ (Ordinal.lift.{u, v} a)

full_name: Ordinal.add_contravariantClass_le
code: instance add_contravariantClass_le : ContravariantClass Ordinal.{u} Ordinal.{u} (· + ·) (· ≤ ·) 
goal: ContravariantClass Ordinal.{u} Ordinal.{u} (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: Ordinal.add_left_cancel
code: theorem add_left_cancel (a) {b c : Ordinal} : a + b = a + c ↔ b = c 
goal: a + b = a + c ↔ b = c

full_name: _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.add_lt_add_iff_left'
code: private theorem add_lt_add_iff_left' (a) {b c : Ordinal} : a + b < a + c ↔ b < c 
goal: a + b < a + c ↔ b < c

full_name: Ordinal.add_covariantClass_lt
code: instance add_covariantClass_lt : CovariantClass Ordinal.{u} Ordinal.{u} (· + ·) (· < ·) 
goal: CovariantClass Ordinal.{u} Ordinal.{u} (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Ordinal.add_contravariantClass_lt
code: instance add_contravariantClass_lt : ContravariantClass Ordinal.{u} Ordinal.{u} (· + ·) (· < ·) 
goal: ContravariantClass Ordinal.{u} Ordinal.{u} (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Ordinal.add_swap_contravariantClass_lt
code: instance add_swap_contravariantClass_lt :
    ContravariantClass Ordinal.{u} Ordinal.{u} (swap (· + ·)) (· < ·) 
goal: ContravariantClass Ordinal.{u} Ordinal.{u} (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: Ordinal.add_le_add_iff_right
code: theorem add_le_add_iff_right {a b : Ordinal} : ∀ n : ℕ, a + n ≤ b + n ↔ a ≤ b
  
goal: a + ↑n ≤ b + ↑n ↔ a ≤ b

full_name: Ordinal.add_right_cancel
code: theorem add_right_cancel {a b : Ordinal} (n : ℕ) : a + n = b + n ↔ a = b 
goal: a + ↑n = b + ↑n ↔ a = b

full_name: Ordinal.add_eq_zero_iff
code: theorem add_eq_zero_iff {a b : Ordinal} : a + b = 0 ↔ a = 0 ∧ b = 0 
goal: a + b = 0 ↔ a = 0 ∧ b = 0

full_name: Ordinal.left_eq_zero_of_add_eq_zero
code: theorem left_eq_zero_of_add_eq_zero {a b : Ordinal} (h : a + b = 0) : a = 0 
goal: a = 0

full_name: Ordinal.right_eq_zero_of_add_eq_zero
code: theorem right_eq_zero_of_add_eq_zero {a b : Ordinal} (h : a + b = 0) : b = 0 
goal: b = 0

full_name: Ordinal.pred
code: /-- The ordinal predecessor of `o` is `o'` if `o = succ o'`,
  and `o` otherwise. -/
def pred (o : Ordinal) : Ordinal 
goal: Ordinal.{u_4}

full_name: Ordinal.pred_succ
code: @[simp]
theorem pred_succ (o) : pred (succ o) = o 
goal: (Order.succ o).pred = o

full_name: Ordinal.pred_le_self
code: theorem pred_le_self (o) : pred o ≤ o 
goal: o.pred ≤ o

full_name: Ordinal.pred_eq_iff_not_succ
code: theorem pred_eq_iff_not_succ {o} : pred o = o ↔ ¬∃ a, o = succ a 
goal: o.pred = o ↔ ¬∃ a, o = Order.succ a

full_name: Ordinal.pred_eq_iff_not_succ'
code: theorem pred_eq_iff_not_succ' {o} : pred o = o ↔ ∀ a, o ≠ succ a 
goal: o.pred = o ↔ ∀ (a : Ordinal.{u_4}), o ≠ Order.succ a

full_name: Ordinal.pred_lt_iff_is_succ
code: theorem pred_lt_iff_is_succ {o} : pred o < o ↔ ∃ a, o = succ a 
goal: o.pred < o ↔ ∃ a, o = Order.succ a

full_name: Ordinal.pred_zero
code: @[simp]
theorem pred_zero : pred 0 = 0 
goal: Ordinal.pred 0 = 0

full_name: Ordinal.succ_pred_iff_is_succ
code: theorem succ_pred_iff_is_succ {o} : succ (pred o) = o ↔ ∃ a, o = succ a 
goal: Order.succ o.pred = o ↔ ∃ a, o = Order.succ a

full_name: Ordinal.succ_lt_of_not_succ
code: theorem succ_lt_of_not_succ {o b : Ordinal} (h : ¬∃ a, o = succ a) : succ b < o ↔ b < o 
goal: Order.succ b < o ↔ b < o

full_name: Ordinal.lt_pred
code: theorem lt_pred {a b} : a < pred b ↔ succ a < b 
goal: a < b.pred ↔ Order.succ a < b

full_name: Ordinal.pred_le
code: theorem pred_le {a b} : pred a ≤ b ↔ a ≤ succ b 
goal: a.pred ≤ b ↔ a ≤ Order.succ b

full_name: Ordinal.lift_is_succ
code: @[simp]
theorem lift_is_succ {o : Ordinal.{v}} : (∃ a, lift.{u} o = succ a) ↔ ∃ a, o = succ a 
goal: (∃ a, Ordinal.lift.{u, v} o = Order.succ a) ↔ ∃ a, o = Order.succ a

full_name: Ordinal.lift_pred
code: @[simp]
theorem lift_pred (o : Ordinal.{v}) : lift.{u} (pred o) = pred (lift.{u} o) 
goal: Ordinal.lift.{u, v} o.pred = (Ordinal.lift.{u, v} o).pred

full_name: Ordinal.IsLimit
code: /-- A limit ordinal is an ordinal which is not zero and not a successor. -/
def IsLimit (o : Ordinal) : Prop 
goal: Prop

full_name: Ordinal.IsLimit.isSuccLimit
code: theorem IsLimit.isSuccLimit {o} (h : IsLimit o) : IsSuccLimit o 
goal: Order.IsSuccLimit o

full_name: Ordinal.IsLimit.succ_lt
code: theorem IsLimit.succ_lt {o a : Ordinal} (h : IsLimit o) : a < o → succ a < o 
goal: a < o → Order.succ a < o

full_name: Ordinal.isSuccLimit_zero
code: theorem isSuccLimit_zero : IsSuccLimit (0 : Ordinal) 
goal: Order.IsSuccLimit 0

full_name: Ordinal.not_zero_isLimit
code: theorem not_zero_isLimit : ¬IsLimit 0
  
goal: ¬Ordinal.IsLimit 0

full_name: Ordinal.not_succ_isLimit
code: theorem not_succ_isLimit (o) : ¬IsLimit (succ o)
  
goal: ¬(Order.succ o).IsLimit

full_name: Ordinal.not_succ_of_isLimit
code: theorem not_succ_of_isLimit {o} (h : IsLimit o) : ¬∃ a, o = succ a
  
goal: ¬∃ a, o = Order.succ a

full_name: Ordinal.succ_lt_of_isLimit
code: theorem succ_lt_of_isLimit {o a : Ordinal} (h : IsLimit o) : succ a < o ↔ a < o 
goal: Order.succ a < o ↔ a < o

full_name: Ordinal.le_succ_of_isLimit
code: theorem le_succ_of_isLimit {o} (h : IsLimit o) {a} : o ≤ succ a ↔ o ≤ a 
goal: o ≤ Order.succ a ↔ o ≤ a

full_name: Ordinal.limit_le
code: theorem limit_le {o} (h : IsLimit o) {a} : o ≤ a ↔ ∀ x < o, x ≤ a 
goal: o ≤ a ↔ ∀ x < o, x ≤ a

full_name: Ordinal.lt_limit
code: theorem lt_limit {o} (h : IsLimit o) {a} : a < o ↔ ∃ x < o, a < x 
goal: a < o ↔ ∃ x < o, a < x

full_name: Ordinal.lift_isLimit
code: @[simp]
theorem lift_isLimit (o : Ordinal.{v}) : IsLimit (lift.{u,v} o) ↔ IsLimit o 
goal: (Ordinal.lift.{u, v} o).IsLimit ↔ o.IsLimit

full_name: Ordinal.IsLimit.pos
code: theorem IsLimit.pos {o : Ordinal} (h : IsLimit o) : 0 < o 
goal: 0 < o

full_name: Ordinal.IsLimit.one_lt
code: theorem IsLimit.one_lt {o : Ordinal} (h : IsLimit o) : 1 < o 
goal: 1 < o

full_name: Ordinal.IsLimit.nat_lt
code: theorem IsLimit.nat_lt {o : Ordinal} (h : IsLimit o) : ∀ n : ℕ, (n : Ordinal) < o
  
goal: ↑n < o

full_name: Ordinal.zero_or_succ_or_limit
code: theorem zero_or_succ_or_limit (o : Ordinal) : o = 0 ∨ (∃ a, o = succ a) ∨ IsLimit o 
goal: o = 0 ∨ (∃ a, o = Order.succ a) ∨ o.IsLimit

full_name: Ordinal.limitRecOn
code: /-- Main induction principle of ordinals: if one can prove a property by
  induction at successor ordinals and at limit ordinals, then it holds for all ordinals. -/
@[elab_as_elim]
def limitRecOn {C : Ordinal → Sort*} (o : Ordinal) (H₁ : C 0) (H₂ : ∀ o, C o → C (succ o))
    (H₃ : ∀ o, IsLimit o → (∀ o' < o, C o') → C o) : C o 
goal: C o

full_name: Ordinal.limitRecOn_zero
code: @[simp]
theorem limitRecOn_zero {C} (H₁ H₂ H₃) : @limitRecOn C 0 H₁ H₂ H₃ = H₁ 
goal: Ordinal.limitRecOn 0 H₁ H₂ H₃ = H₁

full_name: Ordinal.limitRecOn_succ
code: @[simp]
theorem limitRecOn_succ {C} (o H₁ H₂ H₃) :
    @limitRecOn C (succ o) H₁ H₂ H₃ = H₂ o (@limitRecOn C o H₁ H₂ H₃) 
goal: (Order.succ o).limitRecOn H₁ H₂ H₃ = H₂ o (o.limitRecOn H₁ H₂ H₃)

full_name: Ordinal.limitRecOn_limit
code: @[simp]
theorem limitRecOn_limit {C} (o H₁ H₂ H₃ h) :
    @limitRecOn C o H₁ H₂ H₃ = H₃ o h fun x _h => @limitRecOn C x H₁ H₂ H₃ 
goal: o.limitRecOn H₁ H₂ H₃ = H₃ o h fun x _h => x.limitRecOn H₁ H₂ H₃

full_name: Ordinal.orderTopOutSucc
code: instance orderTopOutSucc (o : Ordinal) : OrderTop (succ o).out.α 
goal: OrderTop (Quotient.out (Order.succ o)).α

full_name: Ordinal.enum_succ_eq_top
code: theorem enum_succ_eq_top {o : Ordinal} :
    enum (· < ·) o
        (by
          rw [type_lt]
          exact lt_succ o) =
      (⊤ : (succ o).out.α) 
goal: Ordinal.enum (fun x x_1 => x < x_1) o ⋯ = ⊤

full_name: Ordinal.has_succ_of_type_succ_lt
code: theorem has_succ_of_type_succ_lt {α} {r : α → α → Prop} [wo : IsWellOrder α r]
    (h : ∀ a < type r, succ a < type r) (x : α) : ∃ y, r x y 
goal: ∃ y, r x y

full_name: Ordinal.out_no_max_of_succ_lt
code: theorem out_no_max_of_succ_lt {o : Ordinal} (ho : ∀ a < o, succ a < o) : NoMaxOrder o.out.α 
goal: NoMaxOrder (Quotient.out o).α

full_name: Ordinal.bounded_singleton
code: theorem bounded_singleton {r : α → α → Prop} [IsWellOrder α r] (hr : (type r).IsLimit) (x) :
    Bounded r {x} 
goal: Set.Bounded r {x}

full_name: Ordinal.type_subrel_lt
code: theorem type_subrel_lt (o : Ordinal.{u}) :
    type (Subrel ((· < ·) : Ordinal → Ordinal → Prop) { o' : Ordinal | o' < o })
      = Ordinal.lift.{u + 1} o 
goal: Ordinal.type (Subrel (fun x x_1 => x < x_1) {o' | o' < o}) = Ordinal.lift.{u + 1, u} o

full_name: Ordinal.mk_initialSeg
code: theorem mk_initialSeg (o : Ordinal.{u}) :
    #{ o' : Ordinal | o' < o } = Cardinal.lift.{u + 1} o.card 
goal: #↑{o' | o' < o} = Cardinal.lift.{u + 1, u} o.card

full_name: Ordinal.IsNormal
code: /-- A normal ordinal function is a strictly increasing function which is
  order-continuous, i.e., the image `f o` of a limit ordinal `o` is the sup of `f a` for
  `a < o`.  -/
def IsNormal (f : Ordinal → Ordinal) : Prop 
goal: Prop

full_name: Ordinal.IsNormal.limit_le
code: theorem IsNormal.limit_le {f} (H : IsNormal f) :
    ∀ {o}, IsLimit o → ∀ {a}, f o ≤ a ↔ ∀ b < o, f b ≤ a 
goal: o.IsLimit → ∀ {a : Ordinal.{u_5}}, f o ≤ a ↔ ∀ b < o, f b ≤ a

full_name: Ordinal.IsNormal.limit_lt
code: theorem IsNormal.limit_lt {f} (H : IsNormal f) {o} (h : IsLimit o) {a} :
    a < f o ↔ ∃ b < o, a < f b 
goal: a < f o ↔ ∃ b < o, a < f b

full_name: Ordinal.IsNormal.strictMono
code: theorem IsNormal.strictMono {f} (H : IsNormal f) : StrictMono f 
goal: StrictMono f

full_name: Ordinal.IsNormal.monotone
code: theorem IsNormal.monotone {f} (H : IsNormal f) : Monotone f 
goal: Monotone f

full_name: Ordinal.isNormal_iff_strictMono_limit
code: theorem isNormal_iff_strictMono_limit (f : Ordinal → Ordinal) :
    IsNormal f ↔ StrictMono f ∧ ∀ o, IsLimit o → ∀ a, (∀ b < o, f b ≤ a) → f o ≤ a 
goal: Ordinal.IsNormal f ↔
  StrictMono f ∧ ∀ (o : Ordinal.{u_4}), o.IsLimit → ∀ (a : Ordinal.{u_5}), (∀ b < o, f b ≤ a) → f o ≤ a

full_name: Ordinal.IsNormal.lt_iff
code: theorem IsNormal.lt_iff {f} (H : IsNormal f) {a b} : f a < f b ↔ a < b 
goal: f a < f b ↔ a < b

full_name: Ordinal.IsNormal.le_iff
code: theorem IsNormal.le_iff {f} (H : IsNormal f) {a b} : f a ≤ f b ↔ a ≤ b 
goal: f a ≤ f b ↔ a ≤ b

full_name: Ordinal.IsNormal.inj
code: theorem IsNormal.inj {f} (H : IsNormal f) {a b} : f a = f b ↔ a = b 
goal: f a = f b ↔ a = b

full_name: Ordinal.IsNormal.self_le
code: theorem IsNormal.self_le {f} (H : IsNormal f) (a) : a ≤ f a 
goal: a ≤ f a

full_name: Ordinal.IsNormal.le_set
code: theorem IsNormal.le_set {f o} (H : IsNormal f) (p : Set Ordinal) (p0 : p.Nonempty) (b)
    (H₂ : ∀ o, b ≤ o ↔ ∀ a ∈ p, a ≤ o) : f b ≤ o ↔ ∀ a ∈ p, f a ≤ o 
goal: f b ≤ o ↔ ∀ a ∈ p, f a ≤ o

full_name: Ordinal.IsNormal.le_set'
code: theorem IsNormal.le_set' {f o} (H : IsNormal f) (p : Set α) (p0 : p.Nonempty) (g : α → Ordinal) (b)
    (H₂ : ∀ o, b ≤ o ↔ ∀ a ∈ p, g a ≤ o) : f b ≤ o ↔ ∀ a ∈ p, f (g a) ≤ o 
goal: f b ≤ o ↔ ∀ a ∈ p, f (g a) ≤ o

full_name: Ordinal.IsNormal.refl
code: theorem IsNormal.refl : IsNormal id 
goal: Ordinal.IsNormal id

full_name: Ordinal.IsNormal.trans
code: theorem IsNormal.trans {f g} (H₁ : IsNormal f) (H₂ : IsNormal g) : IsNormal (f ∘ g) 
goal: Ordinal.IsNormal (f ∘ g)

full_name: Ordinal.IsNormal.isLimit
code: theorem IsNormal.isLimit {f} (H : IsNormal f) {o} (l : IsLimit o) : IsLimit (f o) 
goal: (f o).IsLimit

full_name: Ordinal.IsNormal.le_iff_eq
code: theorem IsNormal.le_iff_eq {f} (H : IsNormal f) {a} : f a ≤ a ↔ f a = a 
goal: f a ≤ a ↔ f a = a

full_name: Ordinal.add_le_of_limit
code: theorem add_le_of_limit {a b c : Ordinal} (h : IsLimit b) : a + b ≤ c ↔ ∀ b' < b, a + b' ≤ c 
goal: a + b ≤ c ↔ ∀ b' < b, a + b' ≤ c

full_name: Ordinal.add_isNormal
code: theorem add_isNormal (a : Ordinal) : IsNormal (a + ·) 
goal: Ordinal.IsNormal fun x => a + x

full_name: Ordinal.add_isLimit
code: theorem add_isLimit (a) {b} : IsLimit b → IsLimit (a + b) 
goal: b.IsLimit → (a + b).IsLimit

full_name: Ordinal.sub_nonempty
code: /-- The set in the definition of subtraction is nonempty. -/
theorem sub_nonempty {a b : Ordinal} : { o | a ≤ b + o }.Nonempty 
goal: {o | a ≤ b + o}.Nonempty

full_name: Ordinal.sub
code: /-- `a - b` is the unique ordinal satisfying `b + (a - b) = a` when `b ≤ a`. -/
instance sub : Sub Ordinal 
goal: Sub Ordinal.{u_4}

full_name: Ordinal.le_add_sub
code: theorem le_add_sub (a b : Ordinal) : a ≤ b + (a - b) 
goal: a ≤ b + (a - b)

full_name: Ordinal.sub_le
code: theorem sub_le {a b c : Ordinal} : a - b ≤ c ↔ a ≤ b + c 
goal: a - b ≤ c ↔ a ≤ b + c

full_name: Ordinal.lt_sub
code: theorem lt_sub {a b c : Ordinal} : a < b - c ↔ c + a < b 
goal: a < b - c ↔ c + a < b

full_name: Ordinal.add_sub_cancel
code: theorem add_sub_cancel (a b : Ordinal) : a + b - a = b 
goal: a + b - a = b

full_name: Ordinal.sub_eq_of_add_eq
code: theorem sub_eq_of_add_eq {a b c : Ordinal} (h : a + b = c) : c - a = b 
goal: c - a = b

full_name: Ordinal.sub_le_self
code: theorem sub_le_self (a b : Ordinal) : a - b ≤ a 
goal: a - b ≤ a

full_name: Ordinal.add_sub_cancel_of_le
code: protected theorem add_sub_cancel_of_le {a b : Ordinal} (h : b ≤ a) : b + (a - b) = a 
goal: b + (a - b) = a

full_name: Ordinal.le_sub_of_le
code: theorem le_sub_of_le {a b c : Ordinal} (h : b ≤ a) : c ≤ a - b ↔ b + c ≤ a 
goal: c ≤ a - b ↔ b + c ≤ a

full_name: Ordinal.sub_lt_of_le
code: theorem sub_lt_of_le {a b c : Ordinal} (h : b ≤ a) : a - b < c ↔ a < b + c 
goal: a - b < c ↔ a < b + c

full_name: Ordinal.existsAddOfLE
code: instance existsAddOfLE : ExistsAddOfLE Ordinal 
goal: ExistsAddOfLE Ordinal.{u_4}

full_name: Ordinal.sub_zero
code: @[simp]
theorem sub_zero (a : Ordinal) : a - 0 = a 
goal: a - 0 = a

full_name: Ordinal.zero_sub
code: @[simp]
theorem zero_sub (a : Ordinal) : 0 - a = 0 
goal: 0 - a = 0

full_name: Ordinal.sub_self
code: @[simp]
theorem sub_self (a : Ordinal) : a - a = 0 
goal: a - a = 0

full_name: Ordinal.sub_eq_zero_iff_le
code: protected theorem sub_eq_zero_iff_le {a b : Ordinal} : a - b = 0 ↔ a ≤ b 
goal: a - b = 0 ↔ a ≤ b

full_name: Ordinal.sub_sub
code: theorem sub_sub (a b c : Ordinal) : a - b - c = a - (b + c) 
goal: a - b - c = a - (b + c)

full_name: Ordinal.add_sub_add_cancel
code: @[simp]
theorem add_sub_add_cancel (a b c : Ordinal) : a + b - (a + c) = b - c 
goal: a + b - (a + c) = b - c

full_name: Ordinal.sub_isLimit
code: theorem sub_isLimit {a b} (l : IsLimit a) (h : b < a) : IsLimit (a - b) 
goal: (a - b).IsLimit

full_name: Ordinal.one_add_omega
code: theorem one_add_omega : 1 + ω = ω 
goal: 1 + ω = ω

full_name: Ordinal.one_add_of_omega_le
code: @[simp]
theorem one_add_of_omega_le {o} (h : ω ≤ o) : 1 + o = o 
goal: 1 + o = o

full_name: Ordinal.monoid
code: /-- The multiplication of ordinals `o₁` and `o₂` is the (well founded) lexicographic order on
`o₂ × o₁`. -/
instance monoid : Monoid Ordinal.{u} 
goal: Monoid Ordinal.{u}

full_name: Ordinal.type_prod_lex
code: @[simp]
theorem type_prod_lex {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [IsWellOrder α r]
    [IsWellOrder β s] : type (Prod.Lex s r) = type r * type s 
goal: Ordinal.type (Prod.Lex s r) = Ordinal.type r * Ordinal.type s

full_name: _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.mul_eq_zero'
code: private theorem mul_eq_zero' {a b : Ordinal} : a * b = 0 ↔ a = 0 ∨ b = 0 
goal: a * b = 0 ↔ a = 0 ∨ b = 0

full_name: Ordinal.monoidWithZero
code: instance monoidWithZero : MonoidWithZero Ordinal 
goal: MonoidWithZero Ordinal.{u_4}

full_name: Ordinal.noZeroDivisors
code: instance noZeroDivisors : NoZeroDivisors Ordinal 
goal: NoZeroDivisors Ordinal.{u_4}

full_name: Ordinal.lift_mul
code: @[simp]
theorem lift_mul (a b : Ordinal.{v}) : lift.{u} (a * b) = lift.{u} a * lift.{u} b 
goal: Ordinal.lift.{u, v} (a * b) = Ordinal.lift.{u, v} a * Ordinal.lift.{u, v} b

full_name: Ordinal.card_mul
code: @[simp]
theorem card_mul (a b) : card (a * b) = card a * card b 
goal: (a * b).card = a.card * b.card

full_name: Ordinal.leftDistribClass
code: instance leftDistribClass : LeftDistribClass Ordinal.{u} 
goal: LeftDistribClass Ordinal.{u}

full_name: Ordinal.mul_succ
code: theorem mul_succ (a b : Ordinal) : a * succ b = a * b + a 
goal: a * Order.succ b = a * b + a

full_name: Ordinal.mul_covariantClass_le
code: instance mul_covariantClass_le : CovariantClass Ordinal.{u} Ordinal.{u} (· * ·) (· ≤ ·) 
goal: CovariantClass Ordinal.{u} Ordinal.{u} (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1

full_name: Ordinal.mul_swap_covariantClass_le
code: instance mul_swap_covariantClass_le :
    CovariantClass Ordinal.{u} Ordinal.{u} (swap (· * ·)) (· ≤ ·) 
goal: CovariantClass Ordinal.{u} Ordinal.{u} (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1

full_name: Ordinal.le_mul_left
code: theorem le_mul_left (a : Ordinal) {b : Ordinal} (hb : 0 < b) : a ≤ a * b 
goal: a ≤ a * b

full_name: Ordinal.le_mul_right
code: theorem le_mul_right (a : Ordinal) {b : Ordinal} (hb : 0 < b) : a ≤ b * a 
goal: a ≤ b * a

full_name: _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.mul_le_of_limit_aux
code: private theorem mul_le_of_limit_aux {α β r s} [IsWellOrder α r] [IsWellOrder β s] {c}
    (h : IsLimit (type s)) (H : ∀ b' < type s, type r * b' ≤ c) (l : c < type r * type s) :
    False 
goal: False

full_name: Ordinal.mul_le_of_limit
code: theorem mul_le_of_limit {a b c : Ordinal} (h : IsLimit b) : a * b ≤ c ↔ ∀ b' < b, a * b' ≤ c 
goal: a * b ≤ c ↔ ∀ b' < b, a * b' ≤ c

full_name: Ordinal.mul_isNormal
code: theorem mul_isNormal {a : Ordinal} (h : 0 < a) : IsNormal (a * ·) 
goal: Ordinal.IsNormal fun x => a * x

full_name: Ordinal.lt_mul_of_limit
code: theorem lt_mul_of_limit {a b c : Ordinal} (h : IsLimit c) : a < b * c ↔ ∃ c' < c, a < b * c' 
goal: a < b * c ↔ ∃ c' < c, a < b * c'

full_name: Ordinal.mul_lt_mul_iff_left
code: theorem mul_lt_mul_iff_left {a b c : Ordinal} (a0 : 0 < a) : a * b < a * c ↔ b < c 
goal: a * b < a * c ↔ b < c

full_name: Ordinal.mul_le_mul_iff_left
code: theorem mul_le_mul_iff_left {a b c : Ordinal} (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c 
goal: a * b ≤ a * c ↔ b ≤ c

full_name: Ordinal.mul_lt_mul_of_pos_left
code: theorem mul_lt_mul_of_pos_left {a b c : Ordinal} (h : a < b) (c0 : 0 < c) : c * a < c * b 
goal: c * a < c * b

full_name: Ordinal.mul_pos
code: theorem mul_pos {a b : Ordinal} (h₁ : 0 < a) (h₂ : 0 < b) : 0 < a * b 
goal: 0 < a * b

full_name: Ordinal.mul_ne_zero
code: theorem mul_ne_zero {a b : Ordinal} : a ≠ 0 → b ≠ 0 → a * b ≠ 0 
goal: a ≠ 0 → b ≠ 0 → a * b ≠ 0

full_name: Ordinal.le_of_mul_le_mul_left
code: theorem le_of_mul_le_mul_left {a b c : Ordinal} (h : c * a ≤ c * b) (h0 : 0 < c) : a ≤ b 
goal: a ≤ b

full_name: Ordinal.mul_right_inj
code: theorem mul_right_inj {a b c : Ordinal} (a0 : 0 < a) : a * b = a * c ↔ b = c 
goal: a * b = a * c ↔ b = c

full_name: Ordinal.mul_isLimit
code: theorem mul_isLimit {a b : Ordinal} (a0 : 0 < a) : IsLimit b → IsLimit (a * b) 
goal: b.IsLimit → (a * b).IsLimit

full_name: Ordinal.mul_isLimit_left
code: theorem mul_isLimit_left {a b : Ordinal} (l : IsLimit a) (b0 : 0 < b) : IsLimit (a * b) 
goal: (a * b).IsLimit

full_name: Ordinal.smul_eq_mul
code: theorem smul_eq_mul : ∀ (n : ℕ) (a : Ordinal), n • a = a * n
  
goal: n • a = a * ↑n

full_name: Ordinal.div_nonempty
code: /-- The set in the definition of division is nonempty. -/
theorem div_nonempty {a b : Ordinal} (h : b ≠ 0) : { o | a < b * succ o }.Nonempty 
goal: {o | a < b * Order.succ o}.Nonempty

full_name: Ordinal.div
code: /-- `a / b` is the unique ordinal `o` satisfying `a = b * o + o'` with `o' < b`. -/
instance div : Div Ordinal 
goal: Div Ordinal.{u_4}

full_name: Ordinal.div_zero
code: @[simp]
theorem div_zero (a : Ordinal) : a / 0 = 0 
goal: a / 0 = 0

full_name: Ordinal.div_def
code: theorem div_def (a) {b : Ordinal} (h : b ≠ 0) : a / b = sInf { o | a < b * succ o } 
goal: a / b = sInf {o | a < b * Order.succ o}

full_name: Ordinal.lt_mul_succ_div
code: theorem lt_mul_succ_div (a) {b : Ordinal} (h : b ≠ 0) : a < b * succ (a / b) 
goal: a < b * Order.succ (a / b)

full_name: Ordinal.lt_mul_div_add
code: theorem lt_mul_div_add (a) {b : Ordinal} (h : b ≠ 0) : a < b * (a / b) + b 
goal: a < b * (a / b) + b

full_name: Ordinal.div_le
code: theorem div_le {a b c : Ordinal} (b0 : b ≠ 0) : a / b ≤ c ↔ a < b * succ c 
goal: a / b ≤ c ↔ a < b * Order.succ c

full_name: Ordinal.lt_div
code: theorem lt_div {a b c : Ordinal} (h : c ≠ 0) : a < b / c ↔ c * succ a ≤ b 
goal: a < b / c ↔ c * Order.succ a ≤ b

full_name: Ordinal.div_pos
code: theorem div_pos {b c : Ordinal} (h : c ≠ 0) : 0 < b / c ↔ c ≤ b 
goal: 0 < b / c ↔ c ≤ b

full_name: Ordinal.le_div
code: theorem le_div {a b c : Ordinal} (c0 : c ≠ 0) : a ≤ b / c ↔ c * a ≤ b 
goal: a ≤ b / c ↔ c * a ≤ b

full_name: Ordinal.div_lt
code: theorem div_lt {a b c : Ordinal} (b0 : b ≠ 0) : a / b < c ↔ a < b * c 
goal: a / b < c ↔ a < b * c

full_name: Ordinal.div_le_of_le_mul
code: theorem div_le_of_le_mul {a b c : Ordinal} (h : a ≤ b * c) : a / b ≤ c 
goal: a / b ≤ c

full_name: Ordinal.mul_lt_of_lt_div
code: theorem mul_lt_of_lt_div {a b c : Ordinal} : a < b / c → c * a < b 
goal: a < b / c → c * a < b

full_name: Ordinal.zero_div
code: @[simp]
theorem zero_div (a : Ordinal) : 0 / a = 0 
goal: 0 / a = 0

full_name: Ordinal.mul_div_le
code: theorem mul_div_le (a b : Ordinal) : b * (a / b) ≤ a 
goal: b * (a / b) ≤ a

full_name: Ordinal.mul_add_div
code: theorem mul_add_div (a) {b : Ordinal} (b0 : b ≠ 0) (c) : (b * a + c) / b = a + c / b 
goal: (b * a + c) / b = a + c / b

full_name: Ordinal.div_eq_zero_of_lt
code: theorem div_eq_zero_of_lt {a b : Ordinal} (h : a < b) : a / b = 0 
goal: a / b = 0

full_name: Ordinal.mul_div_cancel
code: @[simp]
theorem mul_div_cancel (a) {b : Ordinal} (b0 : b ≠ 0) : b * a / b = a 
goal: b * a / b = a

full_name: Ordinal.div_one
code: @[simp]
theorem div_one (a : Ordinal) : a / 1 = a 
goal: a / 1 = a

full_name: Ordinal.div_self
code: @[simp]
theorem div_self {a : Ordinal} (h : a ≠ 0) : a / a = 1 
goal: a / a = 1

full_name: Ordinal.mul_sub
code: theorem mul_sub (a b c : Ordinal) : a * (b - c) = a * b - a * c 
goal: a * (b - c) = a * b - a * c

full_name: Ordinal.isLimit_add_iff
code: theorem isLimit_add_iff {a b} : IsLimit (a + b) ↔ IsLimit b ∨ b = 0 ∧ IsLimit a 
goal: (a + b).IsLimit ↔ b.IsLimit ∨ b = 0 ∧ a.IsLimit

full_name: Ordinal.dvd_add_iff
code: theorem dvd_add_iff : ∀ {a b c : Ordinal}, a ∣ b → (a ∣ b + c ↔ a ∣ c)
  
goal: a ∣ b → (a ∣ b + c ↔ a ∣ c)

full_name: Ordinal.div_mul_cancel
code: theorem div_mul_cancel : ∀ {a b : Ordinal}, a ≠ 0 → a ∣ b → a * (b / a) = b
  
goal: a ≠ 0 → a ∣ b → a * (b / a) = b

full_name: Ordinal.le_of_dvd
code: theorem le_of_dvd : ∀ {a b : Ordinal}, b ≠ 0 → a ∣ b → a ≤ b
  -- Porting note: `⟨b, rfl⟩ => by` → `⟨b, e⟩ => by subst e`
  
goal: b ≠ 0 → a ∣ b → a ≤ b

full_name: Ordinal.dvd_antisymm
code: theorem dvd_antisymm {a b : Ordinal} (h₁ : a ∣ b) (h₂ : b ∣ a) : a = b 
goal: a = b

full_name: Ordinal.isAntisymm
code: instance isAntisymm : IsAntisymm Ordinal (· ∣ ·) 
goal: IsAntisymm Ordinal.{u_4} fun x x_1 => x ∣ x_1

full_name: Ordinal.mod
code: /-- `a % b` is the unique ordinal `o'` satisfying
  `a = b * o + o'` with `o' < b`. -/
instance mod : Mod Ordinal 
goal: Mod Ordinal.{u_4}

full_name: Ordinal.mod_def
code: theorem mod_def (a b : Ordinal) : a % b = a - b * (a / b) 
goal: a % b = a - b * (a / b)

full_name: Ordinal.mod_le
code: theorem mod_le (a b : Ordinal) : a % b ≤ a 
goal: a % b ≤ a

full_name: Ordinal.mod_zero
code: @[simp]
theorem mod_zero (a : Ordinal) : a % 0 = a 
goal: a % 0 = a

full_name: Ordinal.mod_eq_of_lt
code: theorem mod_eq_of_lt {a b : Ordinal} (h : a < b) : a % b = a 
goal: a % b = a

full_name: Ordinal.zero_mod
code: @[simp]
theorem zero_mod (b : Ordinal) : 0 % b = 0 
goal: 0 % b = 0

full_name: Ordinal.div_add_mod
code: theorem div_add_mod (a b : Ordinal) : b * (a / b) + a % b = a 
goal: b * (a / b) + a % b = a

full_name: Ordinal.mod_lt
code: theorem mod_lt (a) {b : Ordinal} (h : b ≠ 0) : a % b < b 
goal: a % b < b

full_name: Ordinal.mod_self
code: @[simp]
theorem mod_self (a : Ordinal) : a % a = 0 
goal: a % a = 0

full_name: Ordinal.mod_one
code: @[simp]
theorem mod_one (a : Ordinal) : a % 1 = 0 
goal: a % 1 = 0

full_name: Ordinal.dvd_of_mod_eq_zero
code: theorem dvd_of_mod_eq_zero {a b : Ordinal} (H : a % b = 0) : b ∣ a 
goal: b ∣ a

full_name: Ordinal.mod_eq_zero_of_dvd
code: theorem mod_eq_zero_of_dvd {a b : Ordinal} (H : b ∣ a) : a % b = 0 
goal: a % b = 0

full_name: Ordinal.dvd_iff_mod_eq_zero
code: theorem dvd_iff_mod_eq_zero {a b : Ordinal} : b ∣ a ↔ a % b = 0 
goal: b ∣ a ↔ a % b = 0

full_name: Ordinal.mul_add_mod_self
code: @[simp]
theorem mul_add_mod_self (x y z : Ordinal) : (x * y + z) % x = z % x 
goal: (x * y + z) % x = z % x

full_name: Ordinal.mul_mod
code: @[simp]
theorem mul_mod (x y : Ordinal) : x * y % x = 0 
goal: x * y % x = 0

full_name: Ordinal.mod_mod_of_dvd
code: theorem mod_mod_of_dvd (a : Ordinal) {b c : Ordinal} (h : c ∣ b) : a % b % c = a % c 
goal: a % b % c = a % c

full_name: Ordinal.mod_mod
code: @[simp]
theorem mod_mod (a b : Ordinal) : a % b % b = a % b 
goal: a % b % b = a % b

full_name: Ordinal.bfamilyOfFamily'
code: /-- Converts a family indexed by a `Type u` to one indexed by an `Ordinal.{u}` using a specified
well-ordering. -/
def bfamilyOfFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) :
    ∀ a < type r, α 
goal: a < Ordinal.type r → α

full_name: Ordinal.bfamilyOfFamily
code: /-- Converts a family indexed by a `Type u` to one indexed by an `Ordinal.{u}` using a well-ordering
given by the axiom of choice. -/
def bfamilyOfFamily {ι : Type u} : (ι → α) → ∀ a < type (@WellOrderingRel ι), α 
goal: (ι → α) → (a : Ordinal.{u}) → a < Ordinal.type WellOrderingRel → α

full_name: Ordinal.familyOfBFamily'
code: /-- Converts a family indexed by an `Ordinal.{u}` to one indexed by a `Type u` using a specified
well-ordering. -/
def familyOfBFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o} (ho : type r = o)
    (f : ∀ a < o, α) : ι → α 
goal: ι → α

full_name: Ordinal.familyOfBFamily
code: /-- Converts a family indexed by an `Ordinal.{u}` to one indexed by a `Type u` using a well-ordering
given by the axiom of choice. -/
def familyOfBFamily (o : Ordinal) (f : ∀ a < o, α) : o.out.α → α 
goal: (Quotient.out o).α → α

full_name: Ordinal.bfamilyOfFamily'_typein
code: @[simp]
theorem bfamilyOfFamily'_typein {ι} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) (i) :
    bfamilyOfFamily' r f (typein r i) (typein_lt_type r i) = f i 
goal: Ordinal.bfamilyOfFamily' r f (Ordinal.typein r i) ⋯ = f i

full_name: Ordinal.bfamilyOfFamily_typein
code: @[simp]
theorem bfamilyOfFamily_typein {ι} (f : ι → α) (i) :
    bfamilyOfFamily f (typein _ i) (typein_lt_type _ i) = f i 
goal: Ordinal.bfamilyOfFamily f (Ordinal.typein WellOrderingRel i) ⋯ = f i

full_name: Ordinal.familyOfBFamily'_enum
code: @[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
theorem familyOfBFamily'_enum {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o}
    (ho : type r = o) (f : ∀ a < o, α) (i hi) :
    familyOfBFamily' r ho f (enum r i (by rwa [ho])) = f i hi 
goal: Ordinal.familyOfBFamily' r ho f (Ordinal.enum r i ⋯) = f i hi

full_name: Ordinal.familyOfBFamily_enum
code: @[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
theorem familyOfBFamily_enum (o : Ordinal) (f : ∀ a < o, α) (i hi) :
    familyOfBFamily o f
        (enum (· < ·) i
          (by
            convert hi
            exact type_lt _)) =
      f i hi 
goal: o.familyOfBFamily f (Ordinal.enum (fun x x_1 => x < x_1) i ⋯) = f i hi

full_name: Ordinal.brange
code: /-- The range of a family indexed by ordinals. -/
def brange (o : Ordinal) (f : ∀ a < o, α) : Set α 
goal: Set α

full_name: Ordinal.mem_brange
code: theorem mem_brange {o : Ordinal} {f : ∀ a < o, α} {a} : a ∈ brange o f ↔ ∃ i hi, f i hi = a 
goal: a ∈ o.brange f ↔ ∃ i, ∃ (hi : i < o), f i hi = a

full_name: Ordinal.mem_brange_self
code: theorem mem_brange_self {o} (f : ∀ a < o, α) (i hi) : f i hi ∈ brange o f 
goal: f i hi ∈ o.brange f

full_name: Ordinal.range_familyOfBFamily'
code: @[simp]
theorem range_familyOfBFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o}
    (ho : type r = o) (f : ∀ a < o, α) : range (familyOfBFamily' r ho f) = brange o f 
goal: Set.range (Ordinal.familyOfBFamily' r ho f) = o.brange f

full_name: Ordinal.range_familyOfBFamily
code: @[simp]
theorem range_familyOfBFamily {o} (f : ∀ a < o, α) : range (familyOfBFamily o f) = brange o f 
goal: Set.range (o.familyOfBFamily f) = o.brange f

full_name: Ordinal.brange_bfamilyOfFamily'
code: @[simp]
theorem brange_bfamilyOfFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) :
    brange _ (bfamilyOfFamily' r f) = range f 
goal: (Ordinal.type r).brange (Ordinal.bfamilyOfFamily' r f) = Set.range f

full_name: Ordinal.brange_bfamilyOfFamily
code: @[simp]
theorem brange_bfamilyOfFamily {ι : Type u} (f : ι → α) : brange _ (bfamilyOfFamily f) = range f 
goal: (Ordinal.type WellOrderingRel).brange (Ordinal.bfamilyOfFamily f) = Set.range f

full_name: Ordinal.brange_const
code: @[simp]
theorem brange_const {o : Ordinal} (ho : o ≠ 0) {c : α} : (brange o fun _ _ => c) = {c} 
goal: (o.brange fun x x => c) = {c}

full_name: Ordinal.comp_bfamilyOfFamily'
code: theorem comp_bfamilyOfFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α)
    (g : α → β) : (fun i hi => g (bfamilyOfFamily' r f i hi)) = bfamilyOfFamily' r (g ∘ f) 
goal: (fun i hi => g (Ordinal.bfamilyOfFamily' r f i hi)) = Ordinal.bfamilyOfFamily' r (g ∘ f)

full_name: Ordinal.comp_bfamilyOfFamily
code: theorem comp_bfamilyOfFamily {ι : Type u} (f : ι → α) (g : α → β) :
    (fun i hi => g (bfamilyOfFamily f i hi)) = bfamilyOfFamily (g ∘ f) 
goal: (fun i hi => g (Ordinal.bfamilyOfFamily f i hi)) = Ordinal.bfamilyOfFamily (g ∘ f)

full_name: Ordinal.comp_familyOfBFamily'
code: theorem comp_familyOfBFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o}
    (ho : type r = o) (f : ∀ a < o, α) (g : α → β) :
    g ∘ familyOfBFamily' r ho f = familyOfBFamily' r ho fun i hi => g (f i hi) 
goal: g ∘ Ordinal.familyOfBFamily' r ho f = Ordinal.familyOfBFamily' r ho fun i hi => g (f i hi)

full_name: Ordinal.comp_familyOfBFamily
code: theorem comp_familyOfBFamily {o} (f : ∀ a < o, α) (g : α → β) :
    g ∘ familyOfBFamily o f = familyOfBFamily o fun i hi => g (f i hi) 
goal: g ∘ o.familyOfBFamily f = o.familyOfBFamily fun i hi => g (f i hi)

full_name: Ordinal.sup
code: /-- The supremum of a family of ordinals -/
def sup {ι : Type u} (f : ι → Ordinal.{max u v}) : Ordinal.{max u v} 
goal: Ordinal.{max u v}

full_name: Ordinal.sSup_eq_sup
code: @[simp]
theorem sSup_eq_sup {ι : Type u} (f : ι → Ordinal.{max u v}) : sSup (Set.range f) = sup.{_, v} f 
goal: sSup (Set.range f) = Ordinal.sup f

full_name: Ordinal.bddAbove_range
code: /-- The range of an indexed ordinal function, whose outputs live in a higher universe than the
    inputs, is always bounded above. See `Ordinal.lsub` for an explicit bound. -/
theorem bddAbove_range {ι : Type u} (f : ι → Ordinal.{max u v}) : BddAbove (Set.range f) 
goal: BddAbove (Set.range f)

full_name: Ordinal.le_sup
code: theorem le_sup {ι : Type u} (f : ι → Ordinal.{max u v}) : ∀ i, f i ≤ sup.{_, v} f 
goal: f i ≤ Ordinal.sup f

full_name: Ordinal.sup_le_iff
code: theorem sup_le_iff {ι : Type u} {f : ι → Ordinal.{max u v}} {a} : sup.{_, v} f ≤ a ↔ ∀ i, f i ≤ a 
goal: Ordinal.sup f ≤ a ↔ ∀ (i : ι), f i ≤ a

full_name: Ordinal.sup_le
code: theorem sup_le {ι : Type u} {f : ι → Ordinal.{max u v}} {a} : (∀ i, f i ≤ a) → sup.{_, v} f ≤ a 
goal: (∀ (i : ι), f i ≤ a) → Ordinal.sup f ≤ a

full_name: Ordinal.lt_sup
code: theorem lt_sup {ι : Type u} {f : ι → Ordinal.{max u v}} {a} : a < sup.{_, v} f ↔ ∃ i, a < f i 
goal: a < Ordinal.sup f ↔ ∃ i, a < f i

full_name: Ordinal.ne_sup_iff_lt_sup
code: theorem ne_sup_iff_lt_sup {ι : Type u} {f : ι → Ordinal.{max u v}} :
    (∀ i, f i ≠ sup.{_, v} f) ↔ ∀ i, f i < sup.{_, v} f 
goal: (∀ (i : ι), f i ≠ Ordinal.sup f) ↔ ∀ (i : ι), f i < Ordinal.sup f

full_name: Ordinal.sup_not_succ_of_ne_sup
code: theorem sup_not_succ_of_ne_sup {ι : Type u} {f : ι → Ordinal.{max u v}}
    (hf : ∀ i, f i ≠ sup.{_, v} f) {a} (hao : a < sup.{_, v} f) : succ a < sup.{_, v} f 
goal: Order.succ a < Ordinal.sup f

full_name: Ordinal.sup_eq_zero_iff
code: @[simp]
theorem sup_eq_zero_iff {ι : Type u} {f : ι → Ordinal.{max u v}} :
    sup.{_, v} f = 0 ↔ ∀ i, f i = 0 
goal: Ordinal.sup f = 0 ↔ ∀ (i : ι), f i = 0

full_name: Ordinal.IsNormal.sup
code: theorem IsNormal.sup {f : Ordinal.{max u v} → Ordinal.{max u w}} (H : IsNormal f) {ι : Type u}
    (g : ι → Ordinal.{max u v}) [Nonempty ι] : f (sup.{_, v} g) = sup.{_, w} (f ∘ g) 
goal: f (Ordinal.sup g) = Ordinal.sup (f ∘ g)

full_name: Ordinal.sup_empty
code: @[simp]
theorem sup_empty {ι} [IsEmpty ι] (f : ι → Ordinal) : sup f = 0 
goal: Ordinal.sup f = 0

full_name: Ordinal.sup_const
code: @[simp]
theorem sup_const {ι} [_hι : Nonempty ι] (o : Ordinal) : (sup fun _ : ι => o) = o 
goal: (Ordinal.sup fun x => o) = o

full_name: Ordinal.sup_unique
code: @[simp]
theorem sup_unique {ι} [Unique ι] (f : ι → Ordinal) : sup f = f default 
goal: Ordinal.sup f = f default

full_name: Ordinal.sup_le_of_range_subset
code: theorem sup_le_of_range_subset {ι ι'} {f : ι → Ordinal} {g : ι' → Ordinal}
    (h : Set.range f ⊆ Set.range g) : sup.{u, max v w} f ≤ sup.{v, max u w} g 
goal: Ordinal.sup f ≤ Ordinal.sup g

full_name: Ordinal.sup_eq_of_range_eq
code: theorem sup_eq_of_range_eq {ι ι'} {f : ι → Ordinal} {g : ι' → Ordinal}
    (h : Set.range f = Set.range g) : sup.{u, max v w} f = sup.{v, max u w} g 
goal: Ordinal.sup f = Ordinal.sup g

full_name: Ordinal.sup_sum
code: @[simp]
theorem sup_sum {α : Type u} {β : Type v} (f : α ⊕ β → Ordinal) :
    sup.{max u v, w} f =
      max (sup.{u, max v w} fun a => f (Sum.inl a)) (sup.{v, max u w} fun b => f (Sum.inr b)) 
goal: Ordinal.sup f = max (Ordinal.sup fun a => f (Sum.inl a)) (Ordinal.sup fun b => f (Sum.inr b))

full_name: Ordinal.unbounded_range_of_sup_ge
code: theorem unbounded_range_of_sup_ge {α β : Type u} (r : α → α → Prop) [IsWellOrder α r] (f : β → α)
    (h : type r ≤ sup.{u, u} (typein r ∘ f)) : Unbounded r (range f) 
goal: Set.Unbounded r (Set.range f)

full_name: Ordinal.le_sup_shrink_equiv
code: theorem le_sup_shrink_equiv {s : Set Ordinal.{u}} (hs : Small.{u} s) (a) (ha : a ∈ s) :
    a ≤ sup.{u, u} fun x => ((@equivShrink s hs).symm x).val 
goal: a ≤ Ordinal.sup fun x => ↑((equivShrink ↑s).symm x)

full_name: Ordinal.small_Iio
code: instance small_Iio (o : Ordinal.{u}) : Small.{u} (Set.Iio o) 
goal: Small.{u, u + 1} ↑(Set.Iio o)

full_name: Ordinal.small_Iic
code: instance small_Iic (o : Ordinal.{u}) : Small.{u} (Set.Iic o) 
goal: Small.{u, u + 1} ↑(Set.Iic o)

full_name: Ordinal.bddAbove_iff_small
code: theorem bddAbove_iff_small {s : Set Ordinal.{u}} : BddAbove s ↔ Small.{u} s 
goal: BddAbove s ↔ Small.{u, u + 1} ↑s

full_name: Ordinal.bddAbove_of_small
code: theorem bddAbove_of_small (s : Set Ordinal.{u}) [h : Small.{u} s] : BddAbove s 
goal: BddAbove s

full_name: Ordinal.sup_eq_sSup
code: theorem sup_eq_sSup {s : Set Ordinal.{u}} (hs : Small.{u} s) :
    (sup.{u, u} fun x => (@equivShrink s hs).symm x) = sSup s 
goal: (Ordinal.sup fun x => ↑((equivShrink ↑s).symm x)) = sSup s

full_name: Ordinal.sSup_ord
code: theorem sSup_ord {s : Set Cardinal.{u}} (hs : BddAbove s) : (sSup s).ord = sSup (ord '' s) 
goal: (sSup s).ord = sSup (Cardinal.ord '' s)

full_name: Ordinal.iSup_ord
code: theorem iSup_ord {ι} {f : ι → Cardinal} (hf : BddAbove (range f)) :
    (iSup f).ord = ⨆ i, (f i).ord 
goal: (iSup f).ord = ⨆ i, (f i).ord

full_name: _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.sup_le_sup
code: private theorem sup_le_sup {ι ι' : Type u} (r : ι → ι → Prop) (r' : ι' → ι' → Prop)
    [IsWellOrder ι r] [IsWellOrder ι' r'] {o} (ho : type r = o) (ho' : type r' = o)
    (f : ∀ a < o, Ordinal.{max u v}) :
    sup.{_, v} (familyOfBFamily' r ho f) ≤ sup.{_, v} (familyOfBFamily' r' ho' f) 
goal: Ordinal.sup (Ordinal.familyOfBFamily' r ho f) ≤ Ordinal.sup (Ordinal.familyOfBFamily' r' ho' f)

full_name: Ordinal.sup_eq_sup
code: theorem sup_eq_sup {ι ι' : Type u} (r : ι → ι → Prop) (r' : ι' → ι' → Prop) [IsWellOrder ι r]
    [IsWellOrder ι' r'] {o : Ordinal.{u}} (ho : type r = o) (ho' : type r' = o)
    (f : ∀ a < o, Ordinal.{max u v}) :
    sup.{_, v} (familyOfBFamily' r ho f) = sup.{_, v} (familyOfBFamily' r' ho' f) 
goal: Ordinal.sup (Ordinal.familyOfBFamily' r ho f) = Ordinal.sup (Ordinal.familyOfBFamily' r' ho' f)

full_name: Ordinal.bsup
code: /-- The supremum of a family of ordinals indexed by the set of ordinals less than some
    `o : Ordinal.{u}`. This is a special case of `sup` over the family provided by
    `familyOfBFamily`. -/
def bsup (o : Ordinal.{u}) (f : ∀ a < o, Ordinal.{max u v}) : Ordinal.{max u v} 
goal: Ordinal.{max u v}

full_name: Ordinal.sup_eq_bsup
code: @[simp]
theorem sup_eq_bsup {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    sup.{_, v} (familyOfBFamily o f) = bsup.{_, v} o f 
goal: Ordinal.sup (o.familyOfBFamily f) = o.bsup f

full_name: Ordinal.sup_eq_bsup'
code: @[simp]
theorem sup_eq_bsup' {o : Ordinal.{u}} {ι} (r : ι → ι → Prop) [IsWellOrder ι r] (ho : type r = o)
    (f : ∀ a < o, Ordinal.{max u v}) : sup.{_, v} (familyOfBFamily' r ho f) = bsup.{_, v} o f 
goal: Ordinal.sup (Ordinal.familyOfBFamily' r ho f) = o.bsup f

full_name: Ordinal.sSup_eq_bsup
code: @[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
theorem sSup_eq_bsup {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    sSup (brange o f) = bsup.{_, v} o f 
goal: sSup (o.brange f) = o.bsup f

full_name: Ordinal.bsup_eq_sup'
code: @[simp]
theorem bsup_eq_sup' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → Ordinal.{max u v}) :
    bsup.{_, v} _ (bfamilyOfFamily' r f) = sup.{_, v} f 
goal: (Ordinal.type r).bsup (Ordinal.bfamilyOfFamily' r f) = Ordinal.sup f

full_name: Ordinal.bsup_eq_bsup
code: theorem bsup_eq_bsup {ι : Type u} (r r' : ι → ι → Prop) [IsWellOrder ι r] [IsWellOrder ι r']
    (f : ι → Ordinal.{max u v}) :
    bsup.{_, v} _ (bfamilyOfFamily' r f) = bsup.{_, v} _ (bfamilyOfFamily' r' f) 
goal: (Ordinal.type r).bsup (Ordinal.bfamilyOfFamily' r f) = (Ordinal.type r').bsup (Ordinal.bfamilyOfFamily' r' f)

full_name: Ordinal.bsup_eq_sup
code: @[simp]
theorem bsup_eq_sup {ι : Type u} (f : ι → Ordinal.{max u v}) :
    bsup.{_, v} _ (bfamilyOfFamily f) = sup.{_, v} f 
goal: (Ordinal.type WellOrderingRel).bsup (Ordinal.bfamilyOfFamily f) = Ordinal.sup f

full_name: Ordinal.bsup_congr
code: @[congr]
theorem bsup_congr {o₁ o₂ : Ordinal.{u}} (f : ∀ a < o₁, Ordinal.{max u v}) (ho : o₁ = o₂) :
    bsup.{_, v} o₁ f = bsup.{_, v} o₂ fun a h => f a (h.trans_eq ho.symm) 
goal: o₁.bsup f = o₂.bsup fun a h => f a ⋯

full_name: Ordinal.bsup_le_iff
code: theorem bsup_le_iff {o f a} : bsup.{u, v} o f ≤ a ↔ ∀ i h, f i h ≤ a 
goal: o.bsup f ≤ a ↔ ∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a

full_name: Ordinal.bsup_le
code: theorem bsup_le {o : Ordinal} {f : ∀ b < o, Ordinal} {a} :
    (∀ i h, f i h ≤ a) → bsup.{u, v} o f ≤ a 
goal: (∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a) → o.bsup f ≤ a

full_name: Ordinal.le_bsup
code: theorem le_bsup {o} (f : ∀ a < o, Ordinal) (i h) : f i h ≤ bsup o f 
goal: f i h ≤ o.bsup f

full_name: Ordinal.lt_bsup
code: theorem lt_bsup {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) {a} :
    a < bsup.{_, v} o f ↔ ∃ i hi, a < f i hi 
goal: a < o.bsup f ↔ ∃ i, ∃ (hi : i < o), a < f i hi

full_name: Ordinal.IsNormal.bsup
code: theorem IsNormal.bsup {f : Ordinal.{max u v} → Ordinal.{max u w}} (H : IsNormal f)
    {o : Ordinal.{u}} :
    ∀ (g : ∀ a < o, Ordinal), o ≠ 0 → f (bsup.{_, v} o g) = bsup.{_, w} o fun a h => f (g a h) 
goal: o ≠ 0 → f (o.bsup g) = o.bsup fun a h => f (g a h)

full_name: Ordinal.lt_bsup_of_ne_bsup
code: theorem lt_bsup_of_ne_bsup {o : Ordinal.{u}} {f : ∀ a < o, Ordinal.{max u v}} :
    (∀ i h, f i h ≠ bsup.{_, v} o f) ↔ ∀ i h, f i h < bsup.{_, v} o f 
goal: (∀ (i : Ordinal.{u}) (h : i < o), f i h ≠ o.bsup f) ↔ ∀ (i : Ordinal.{u}) (h : i < o), f i h < o.bsup f

full_name: Ordinal.bsup_not_succ_of_ne_bsup
code: theorem bsup_not_succ_of_ne_bsup {o : Ordinal.{u}} {f : ∀ a < o, Ordinal.{max u v}}
    (hf : ∀ {i : Ordinal} (h : i < o), f i h ≠ bsup.{_, v} o f) (a) :
    a < bsup.{_, v} o f → succ a < bsup.{_, v} o f 
goal: a < o.bsup f → Order.succ a < o.bsup f

full_name: Ordinal.bsup_eq_zero_iff
code: @[simp]
theorem bsup_eq_zero_iff {o} {f : ∀ a < o, Ordinal} : bsup o f = 0 ↔ ∀ i hi, f i hi = 0 
goal: o.bsup f = 0 ↔ ∀ (i : Ordinal.{u_4}) (hi : i < o), f i hi = 0

full_name: Ordinal.lt_bsup_of_limit
code: theorem lt_bsup_of_limit {o : Ordinal} {f : ∀ a < o, Ordinal}
    (hf : ∀ {a a'} (ha : a < o) (ha' : a' < o), a < a' → f a ha < f a' ha')
    (ho : ∀ a < o, succ a < o) (i h) : f i h < bsup o f 
goal: f i h < o.bsup f

full_name: Ordinal.bsup_succ_of_mono
code: theorem bsup_succ_of_mono {o : Ordinal} {f : ∀ a < succ o, Ordinal}
    (hf : ∀ {i j} (hi hj), i ≤ j → f i hi ≤ f j hj) : bsup _ f = f o (lt_succ o) 
goal: (Order.succ o).bsup f = f o ⋯

full_name: Ordinal.bsup_zero
code: @[simp]
theorem bsup_zero (f : ∀ a < (0 : Ordinal), Ordinal) : bsup 0 f = 0 
goal: Ordinal.bsup 0 f = 0

full_name: Ordinal.bsup_const
code: theorem bsup_const {o : Ordinal.{u}} (ho : o ≠ 0) (a : Ordinal.{max u v}) :
    (bsup.{_, v} o fun _ _ => a) = a 
goal: (o.bsup fun x x => a) = a

full_name: Ordinal.bsup_one
code: @[simp]
theorem bsup_one (f : ∀ a < (1 : Ordinal), Ordinal) : bsup 1 f = f 0 zero_lt_one 
goal: Ordinal.bsup 1 f = f 0 ⋯

full_name: Ordinal.bsup_le_of_brange_subset
code: theorem bsup_le_of_brange_subset {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
    (h : brange o f ⊆ brange o' g) : bsup.{u, max v w} o f ≤ bsup.{v, max u w} o' g 
goal: o.bsup f ≤ o'.bsup g

full_name: Ordinal.bsup_eq_of_brange_eq
code: theorem bsup_eq_of_brange_eq {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
    (h : brange o f = brange o' g) : bsup.{u, max v w} o f = bsup.{v, max u w} o' g 
goal: o.bsup f = o'.bsup g

full_name: Ordinal.lsub
code: /-- The least strict upper bound of a family of ordinals. -/
def lsub {ι} (f : ι → Ordinal) : Ordinal 
goal: Ordinal.{max u_5 u_4}

full_name: Ordinal.sup_eq_lsub
code: @[simp]
theorem sup_eq_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) :
    sup.{_, v} (succ ∘ f) = lsub.{_, v} f 
goal: Ordinal.sup (Order.succ ∘ f) = Ordinal.lsub f

full_name: Ordinal.lsub_le_iff
code: theorem lsub_le_iff {ι : Type u} {f : ι → Ordinal.{max u v}} {a} :
    lsub.{_, v} f ≤ a ↔ ∀ i, f i < a 
goal: Ordinal.lsub f ≤ a ↔ ∀ (i : ι), f i < a

full_name: Ordinal.lsub_le
code: theorem lsub_le {ι} {f : ι → Ordinal} {a} : (∀ i, f i < a) → lsub f ≤ a 
goal: (∀ (i : ι), f i < a) → Ordinal.lsub f ≤ a

full_name: Ordinal.lt_lsub
code: theorem lt_lsub {ι} (f : ι → Ordinal) (i) : f i < lsub f 
goal: f i < Ordinal.lsub f

full_name: Ordinal.lt_lsub_iff
code: theorem lt_lsub_iff {ι : Type u} {f : ι → Ordinal.{max u v}} {a} :
    a < lsub.{_, v} f ↔ ∃ i, a ≤ f i 
goal: a < Ordinal.lsub f ↔ ∃ i, a ≤ f i

full_name: Ordinal.sup_le_lsub
code: theorem sup_le_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) : sup.{_, v} f ≤ lsub.{_, v} f 
goal: Ordinal.sup f ≤ Ordinal.lsub f

full_name: Ordinal.lsub_le_sup_succ
code: theorem lsub_le_sup_succ {ι : Type u} (f : ι → Ordinal.{max u v}) :
    lsub.{_, v} f ≤ succ (sup.{_, v} f) 
goal: Ordinal.lsub f ≤ Order.succ (Ordinal.sup f)

full_name: Ordinal.sup_eq_lsub_or_sup_succ_eq_lsub
code: theorem sup_eq_lsub_or_sup_succ_eq_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) :
    sup.{_, v} f = lsub.{_, v} f ∨ succ (sup.{_, v} f) = lsub.{_, v} f 
goal: Ordinal.sup f = Ordinal.lsub f ∨ Order.succ (Ordinal.sup f) = Ordinal.lsub f

full_name: Ordinal.sup_succ_le_lsub
code: theorem sup_succ_le_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) :
    succ (sup.{_, v} f) ≤ lsub.{_, v} f ↔ ∃ i, f i = sup.{_, v} f 
goal: Order.succ (Ordinal.sup f) ≤ Ordinal.lsub f ↔ ∃ i, f i = Ordinal.sup f

full_name: Ordinal.sup_succ_eq_lsub
code: theorem sup_succ_eq_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) :
    succ (sup.{_, v} f) = lsub.{_, v} f ↔ ∃ i, f i = sup.{_, v} f 
goal: Order.succ (Ordinal.sup f) = Ordinal.lsub f ↔ ∃ i, f i = Ordinal.sup f

full_name: Ordinal.sup_eq_lsub_iff_succ
code: theorem sup_eq_lsub_iff_succ {ι : Type u} (f : ι → Ordinal.{max u v}) :
    sup.{_, v} f = lsub.{_, v} f ↔ ∀ a < lsub.{_, v} f, succ a < lsub.{_, v} f 
goal: Ordinal.sup f = Ordinal.lsub f ↔ ∀ a < Ordinal.lsub f, Order.succ a < Ordinal.lsub f

full_name: Ordinal.sup_eq_lsub_iff_lt_sup
code: theorem sup_eq_lsub_iff_lt_sup {ι : Type u} (f : ι → Ordinal.{max u v}) :
    sup.{_, v} f = lsub.{_, v} f ↔ ∀ i, f i < sup.{_, v} f 
goal: Ordinal.sup f = Ordinal.lsub f ↔ ∀ (i : ι), f i < Ordinal.sup f

full_name: Ordinal.lsub_empty
code: @[simp]
theorem lsub_empty {ι} [h : IsEmpty ι] (f : ι → Ordinal) : lsub f = 0 
goal: Ordinal.lsub f = 0

full_name: Ordinal.lsub_pos
code: theorem lsub_pos {ι : Type u} [h : Nonempty ι] (f : ι → Ordinal.{max u v}) : 0 < lsub.{_, v} f 
goal: 0 < Ordinal.lsub f

full_name: Ordinal.lsub_eq_zero_iff
code: @[simp]
theorem lsub_eq_zero_iff {ι : Type u} (f : ι → Ordinal.{max u v}) :
    lsub.{_, v} f = 0 ↔ IsEmpty ι 
goal: Ordinal.lsub f = 0 ↔ IsEmpty ι

full_name: Ordinal.lsub_const
code: @[simp]
theorem lsub_const {ι} [Nonempty ι] (o : Ordinal) : (lsub fun _ : ι => o) = succ o 
goal: (Ordinal.lsub fun x => o) = Order.succ o

full_name: Ordinal.lsub_unique
code: @[simp]
theorem lsub_unique {ι} [Unique ι] (f : ι → Ordinal) : lsub f = succ (f default) 
goal: Ordinal.lsub f = Order.succ (f default)

full_name: Ordinal.lsub_le_of_range_subset
code: theorem lsub_le_of_range_subset {ι ι'} {f : ι → Ordinal} {g : ι' → Ordinal}
    (h : Set.range f ⊆ Set.range g) : lsub.{u, max v w} f ≤ lsub.{v, max u w} g 
goal: Ordinal.lsub f ≤ Ordinal.lsub g

full_name: Ordinal.lsub_eq_of_range_eq
code: theorem lsub_eq_of_range_eq {ι ι'} {f : ι → Ordinal} {g : ι' → Ordinal}
    (h : Set.range f = Set.range g) : lsub.{u, max v w} f = lsub.{v, max u w} g 
goal: Ordinal.lsub f = Ordinal.lsub g

full_name: Ordinal.lsub_sum
code: @[simp]
theorem lsub_sum {α : Type u} {β : Type v} (f : α ⊕ β → Ordinal) :
    lsub.{max u v, w} f =
      max (lsub.{u, max v w} fun a => f (Sum.inl a)) (lsub.{v, max u w} fun b => f (Sum.inr b)) 
goal: Ordinal.lsub f = max (Ordinal.lsub fun a => f (Sum.inl a)) (Ordinal.lsub fun b => f (Sum.inr b))

full_name: Ordinal.lsub_not_mem_range
code: theorem lsub_not_mem_range {ι : Type u} (f : ι → Ordinal.{max u v}) :
    lsub.{_, v} f ∉ Set.range f 
goal: Ordinal.lsub f ∉ Set.range f

full_name: Ordinal.nonempty_compl_range
code: theorem nonempty_compl_range {ι : Type u} (f : ι → Ordinal.{max u v}) : (Set.range f)ᶜ.Nonempty 
goal: (Set.range f)ᶜ.Nonempty

full_name: Ordinal.lsub_typein
code: @[simp]
theorem lsub_typein (o : Ordinal) : lsub.{u, u} (typein ((· < ·) : o.out.α → o.out.α → Prop)) = o 
goal: Ordinal.lsub (Ordinal.typein fun x x_1 => x < x_1) = o

full_name: Ordinal.sup_typein_limit
code: theorem sup_typein_limit {o : Ordinal} (ho : ∀ a, a < o → succ a < o) :
    sup.{u, u} (typein ((· < ·) : o.out.α → o.out.α → Prop)) = o 
goal: Ordinal.sup (Ordinal.typein fun x x_1 => x < x_1) = o

full_name: Ordinal.sup_typein_succ
code: @[simp]
theorem sup_typein_succ {o : Ordinal} :
    sup.{u, u} (typein ((· < ·) : (succ o).out.α → (succ o).out.α → Prop)) = o 
goal: Ordinal.sup (Ordinal.typein fun x x_1 => x < x_1) = o

full_name: Ordinal.blsub
code: /-- The least strict upper bound of a family of ordinals indexed by the set of ordinals less than
    some `o : Ordinal.{u}`.

    This is to `lsub` as `bsup` is to `sup`. -/
def blsub (o : Ordinal.{u}) (f : ∀ a < o, Ordinal.{max u v}) : Ordinal.{max u v} 
goal: Ordinal.{max u v}

full_name: Ordinal.bsup_eq_blsub
code: @[simp]
theorem bsup_eq_blsub (o : Ordinal.{u}) (f : ∀ a < o, Ordinal.{max u v}) :
    (bsup.{_, v} o fun a ha => succ (f a ha)) = blsub.{_, v} o f 
goal: (o.bsup fun a ha => Order.succ (f a ha)) = o.blsub f

full_name: Ordinal.lsub_eq_blsub'
code: theorem lsub_eq_blsub' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o} (ho : type r = o)
    (f : ∀ a < o, Ordinal.{max u v}) : lsub.{_, v} (familyOfBFamily' r ho f) = blsub.{_, v} o f 
goal: Ordinal.lsub (Ordinal.familyOfBFamily' r ho f) = o.blsub f

full_name: Ordinal.lsub_eq_lsub
code: theorem lsub_eq_lsub {ι ι' : Type u} (r : ι → ι → Prop) (r' : ι' → ι' → Prop) [IsWellOrder ι r]
    [IsWellOrder ι' r'] {o} (ho : type r = o) (ho' : type r' = o)
    (f : ∀ a < o, Ordinal.{max u v}) :
    lsub.{_, v} (familyOfBFamily' r ho f) = lsub.{_, v} (familyOfBFamily' r' ho' f) 
goal: Ordinal.lsub (Ordinal.familyOfBFamily' r ho f) = Ordinal.lsub (Ordinal.familyOfBFamily' r' ho' f)

full_name: Ordinal.lsub_eq_blsub
code: @[simp]
theorem lsub_eq_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    lsub.{_, v} (familyOfBFamily o f) = blsub.{_, v} o f 
goal: Ordinal.lsub (o.familyOfBFamily f) = o.blsub f

full_name: Ordinal.blsub_eq_lsub'
code: @[simp]
theorem blsub_eq_lsub' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r]
    (f : ι → Ordinal.{max u v}) : blsub.{_, v} _ (bfamilyOfFamily' r f) = lsub.{_, v} f 
goal: (Ordinal.type r).blsub (Ordinal.bfamilyOfFamily' r f) = Ordinal.lsub f

full_name: Ordinal.blsub_eq_blsub
code: theorem blsub_eq_blsub {ι : Type u} (r r' : ι → ι → Prop) [IsWellOrder ι r] [IsWellOrder ι r']
    (f : ι → Ordinal.{max u v}) :
    blsub.{_, v} _ (bfamilyOfFamily' r f) = blsub.{_, v} _ (bfamilyOfFamily' r' f) 
goal: (Ordinal.type r).blsub (Ordinal.bfamilyOfFamily' r f) = (Ordinal.type r').blsub (Ordinal.bfamilyOfFamily' r' f)

full_name: Ordinal.blsub_eq_lsub
code: @[simp]
theorem blsub_eq_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) :
    blsub.{_, v} _ (bfamilyOfFamily f) = lsub.{_, v} f 
goal: (Ordinal.type WellOrderingRel).blsub (Ordinal.bfamilyOfFamily f) = Ordinal.lsub f

full_name: Ordinal.blsub_congr
code: @[congr]
theorem blsub_congr {o₁ o₂ : Ordinal.{u}} (f : ∀ a < o₁, Ordinal.{max u v}) (ho : o₁ = o₂) :
    blsub.{_, v} o₁ f = blsub.{_, v} o₂ fun a h => f a (h.trans_eq ho.symm) 
goal: o₁.blsub f = o₂.blsub fun a h => f a ⋯

full_name: Ordinal.blsub_le_iff
code: theorem blsub_le_iff {o : Ordinal.{u}} {f : ∀ a < o, Ordinal.{max u v}} {a} :
    blsub.{_, v} o f ≤ a ↔ ∀ i h, f i h < a 
goal: o.blsub f ≤ a ↔ ∀ (i : Ordinal.{u}) (h : i < o), f i h < a

full_name: Ordinal.blsub_le
code: theorem blsub_le {o : Ordinal} {f : ∀ b < o, Ordinal} {a} : (∀ i h, f i h < a) → blsub o f ≤ a 
goal: (∀ (i : Ordinal.{u_4}) (h : i < o), f i h < a) → o.blsub f ≤ a

full_name: Ordinal.lt_blsub
code: theorem lt_blsub {o} (f : ∀ a < o, Ordinal) (i h) : f i h < blsub o f 
goal: f i h < o.blsub f

full_name: Ordinal.lt_blsub_iff
code: theorem lt_blsub_iff {o : Ordinal.{u}} {f : ∀ b < o, Ordinal.{max u v}} {a} :
    a < blsub.{_, v} o f ↔ ∃ i hi, a ≤ f i hi 
goal: a < o.blsub f ↔ ∃ i, ∃ (hi : i < o), a ≤ f i hi

full_name: Ordinal.bsup_le_blsub
code: theorem bsup_le_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    bsup.{_, v} o f ≤ blsub.{_, v} o f 
goal: o.bsup f ≤ o.blsub f

full_name: Ordinal.blsub_le_bsup_succ
code: theorem blsub_le_bsup_succ {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    blsub.{_, v} o f ≤ succ (bsup.{_, v} o f) 
goal: o.blsub f ≤ Order.succ (o.bsup f)

full_name: Ordinal.bsup_eq_blsub_or_succ_bsup_eq_blsub
code: theorem bsup_eq_blsub_or_succ_bsup_eq_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    bsup.{_, v} o f = blsub.{_, v} o f ∨ succ (bsup.{_, v} o f) = blsub.{_, v} o f 
goal: o.bsup f = o.blsub f ∨ Order.succ (o.bsup f) = o.blsub f

full_name: Ordinal.bsup_succ_le_blsub
code: theorem bsup_succ_le_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    succ (bsup.{_, v} o f) ≤ blsub.{_, v} o f ↔ ∃ i hi, f i hi = bsup.{_, v} o f 
goal: Order.succ (o.bsup f) ≤ o.blsub f ↔ ∃ i, ∃ (hi : i < o), f i hi = o.bsup f

full_name: Ordinal.bsup_succ_eq_blsub
code: theorem bsup_succ_eq_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    succ (bsup.{_, v} o f) = blsub.{_, v} o f ↔ ∃ i hi, f i hi = bsup.{_, v} o f 
goal: Order.succ (o.bsup f) = o.blsub f ↔ ∃ i, ∃ (hi : i < o), f i hi = o.bsup f

full_name: Ordinal.bsup_eq_blsub_iff_succ
code: theorem bsup_eq_blsub_iff_succ {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    bsup.{_, v} o f = blsub.{_, v} o f ↔ ∀ a < blsub.{_, v} o f, succ a < blsub.{_, v} o f 
goal: o.bsup f = o.blsub f ↔ ∀ a < o.blsub f, Order.succ a < o.blsub f

full_name: Ordinal.bsup_eq_blsub_iff_lt_bsup
code: theorem bsup_eq_blsub_iff_lt_bsup {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    bsup.{_, v} o f = blsub.{_, v} o f ↔ ∀ i hi, f i hi < bsup.{_, v} o f 
goal: o.bsup f = o.blsub f ↔ ∀ (i : Ordinal.{u}) (hi : i < o), f i hi < o.bsup f

full_name: Ordinal.bsup_eq_blsub_of_lt_succ_limit
code: theorem bsup_eq_blsub_of_lt_succ_limit {o : Ordinal.{u}} (ho : IsLimit o)
    {f : ∀ a < o, Ordinal.{max u v}} (hf : ∀ a ha, f a ha < f (succ a) (ho.2 a ha)) :
    bsup.{_, v} o f = blsub.{_, v} o f 
goal: o.bsup f = o.blsub f

full_name: Ordinal.blsub_succ_of_mono
code: theorem blsub_succ_of_mono {o : Ordinal.{u}} {f : ∀ a < succ o, Ordinal.{max u v}}
    (hf : ∀ {i j} (hi hj), i ≤ j → f i hi ≤ f j hj) : blsub.{_, v} _ f = succ (f o (lt_succ o)) 
goal: (Order.succ o).blsub f = Order.succ (f o ⋯)

full_name: Ordinal.blsub_eq_zero_iff
code: @[simp]
theorem blsub_eq_zero_iff {o} {f : ∀ a < o, Ordinal} : blsub o f = 0 ↔ o = 0 
goal: o.blsub f = 0 ↔ o = 0

full_name: Ordinal.blsub_zero
code: @[simp]
theorem blsub_zero (f : ∀ a < (0 : Ordinal), Ordinal) : blsub 0 f = 0 
goal: Ordinal.blsub 0 f = 0

full_name: Ordinal.blsub_pos
code: theorem blsub_pos {o : Ordinal} (ho : 0 < o) (f : ∀ a < o, Ordinal) : 0 < blsub o f 
goal: 0 < o.blsub f

full_name: Ordinal.blsub_type
code: theorem blsub_type {α : Type u} (r : α → α → Prop) [IsWellOrder α r]
    (f : ∀ a < type r, Ordinal.{max u v}) :
    blsub.{_, v} (type r) f = lsub.{_, v} fun a => f (typein r a) (typein_lt_type _ _) 
goal: (Ordinal.type r).blsub f = Ordinal.lsub fun a => f (Ordinal.typein r a) ⋯

full_name: Ordinal.blsub_const
code: theorem blsub_const {o : Ordinal} (ho : o ≠ 0) (a : Ordinal) :
    (blsub.{u, v} o fun _ _ => a) = succ a 
goal: (o.blsub fun x x => a) = Order.succ a

full_name: Ordinal.blsub_one
code: @[simp]
theorem blsub_one (f : ∀ a < (1 : Ordinal), Ordinal) : blsub 1 f = succ (f 0 zero_lt_one) 
goal: Ordinal.blsub 1 f = Order.succ (f 0 ⋯)

full_name: Ordinal.blsub_id
code: @[simp]
theorem blsub_id : ∀ o, (blsub.{u, u} o fun x _ => x) = o 
goal: (o.blsub fun x x_1 => x) = o

full_name: Ordinal.bsup_id_limit
code: theorem bsup_id_limit {o : Ordinal} : (∀ a < o, succ a < o) → (bsup.{u, u} o fun x _ => x) = o 
goal: (∀ a < o, Order.succ a < o) → (o.bsup fun x x_1 => x) = o

full_name: Ordinal.bsup_id_succ
code: @[simp]
theorem bsup_id_succ (o) : (bsup.{u, u} (succ o) fun x _ => x) = o 
goal: ((Order.succ o).bsup fun x x_1 => x) = o

full_name: Ordinal.blsub_le_of_brange_subset
code: theorem blsub_le_of_brange_subset {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
    (h : brange o f ⊆ brange o' g) : blsub.{u, max v w} o f ≤ blsub.{v, max u w} o' g 
goal: o.blsub f ≤ o'.blsub g

full_name: Ordinal.blsub_eq_of_brange_eq
code: theorem blsub_eq_of_brange_eq {o o'} {f : ∀ a < o, Ordinal} {g : ∀ a < o', Ordinal}
    (h : { o | ∃ i hi, f i hi = o } = { o | ∃ i hi, g i hi = o }) :
    blsub.{u, max v w} o f = blsub.{v, max u w} o' g 
goal: o.blsub f = o'.blsub g

full_name: Ordinal.bsup_comp
code: theorem bsup_comp {o o' : Ordinal.{max u v}} {f : ∀ a < o, Ordinal.{max u v w}}
    (hf : ∀ {i j} (hi) (hj), i ≤ j → f i hi ≤ f j hj) {g : ∀ a < o', Ordinal.{max u v}}
    (hg : blsub.{_, u} o' g = o) :
    (bsup.{_, w} o' fun a ha => f (g a ha) (by rw [← hg]; apply lt_blsub)) = bsup.{_, w} o f 
goal: (o'.bsup fun a ha => f (g a ha) ⋯) = o.bsup f

full_name: Ordinal.blsub_comp
code: theorem blsub_comp {o o' : Ordinal.{max u v}} {f : ∀ a < o, Ordinal.{max u v w}}
    (hf : ∀ {i j} (hi) (hj), i ≤ j → f i hi ≤ f j hj) {g : ∀ a < o', Ordinal.{max u v}}
    (hg : blsub.{_, u} o' g = o) :
    (blsub.{_, w} o' fun a ha => f (g a ha) (by rw [← hg]; apply lt_blsub)) = blsub.{_, w} o f 
goal: (o'.blsub fun a ha => f (g a ha) ⋯) = o.blsub f

full_name: Ordinal.IsNormal.bsup_eq
code: theorem IsNormal.bsup_eq {f : Ordinal.{u} → Ordinal.{max u v}} (H : IsNormal f) {o : Ordinal.{u}}
    (h : IsLimit o) : (Ordinal.bsup.{_, v} o fun x _ => f x) = f o 
goal: (o.bsup fun x x_1 => f x) = f o

full_name: Ordinal.IsNormal.blsub_eq
code: theorem IsNormal.blsub_eq {f : Ordinal.{u} → Ordinal.{max u v}} (H : IsNormal f) {o : Ordinal.{u}}
    (h : IsLimit o) : (blsub.{_, v} o fun x _ => f x) = f o 
goal: (o.blsub fun x x_1 => f x) = f o

full_name: Ordinal.isNormal_iff_lt_succ_and_bsup_eq
code: theorem isNormal_iff_lt_succ_and_bsup_eq {f : Ordinal.{u} → Ordinal.{max u v}} :
    IsNormal f ↔ (∀ a, f a < f (succ a)) ∧ ∀ o, IsLimit o → (bsup.{_, v} o fun x _ => f x) = f o 
goal: Ordinal.IsNormal f ↔
  (∀ (a : Ordinal.{u}), f a < f (Order.succ a)) ∧ ∀ (o : Ordinal.{u}), o.IsLimit → (o.bsup fun x x_1 => f x) = f o

full_name: Ordinal.isNormal_iff_lt_succ_and_blsub_eq
code: theorem isNormal_iff_lt_succ_and_blsub_eq {f : Ordinal.{u} → Ordinal.{max u v}} :
    IsNormal f ↔ (∀ a, f a < f (succ a)) ∧
      ∀ o, IsLimit o → (blsub.{_, v} o fun x _ => f x) = f o 
goal: Ordinal.IsNormal f ↔
  (∀ (a : Ordinal.{u}), f a < f (Order.succ a)) ∧ ∀ (o : Ordinal.{u}), o.IsLimit → (o.blsub fun x x_1 => f x) = f o

full_name: Ordinal.IsNormal.eq_iff_zero_and_succ
code: theorem IsNormal.eq_iff_zero_and_succ {f g : Ordinal.{u} → Ordinal.{u}} (hf : IsNormal f)
    (hg : IsNormal g) : f = g ↔ f 0 = g 0 ∧ ∀ a, f a = g a → f (succ a) = g (succ a) 
goal: f = g ↔ f 0 = g 0 ∧ ∀ (a : Ordinal.{u}), f a = g a → f (Order.succ a) = g (Order.succ a)

full_name: Ordinal.blsub₂
code: /-- A two-argument version of `Ordinal.blsub`.
We don't develop a full API for this, since it's only used in a handful of existence results. -/
def blsub₂ (o₁ o₂ : Ordinal) (op : {a : Ordinal} → (a < o₁) → {b : Ordinal} → (b < o₂) → Ordinal) :
    Ordinal 
goal: Ordinal.{max u_6 u_4 u_5}

full_name: Ordinal.lt_blsub₂
code: theorem lt_blsub₂ {o₁ o₂ : Ordinal}
    (op : {a : Ordinal} → (a < o₁) → {b : Ordinal} → (b < o₂) → Ordinal) {a b : Ordinal}
    (ha : a < o₁) (hb : b < o₂) : op ha hb < blsub₂ o₁ o₂ op 
goal: op ha hb < o₁.blsub₂ o₂ fun {a} => op

full_name: Ordinal.mex
code: /-- The minimum excluded ordinal in a family of ordinals. -/
def mex {ι : Type u} (f : ι → Ordinal.{max u v}) : Ordinal 
goal: Ordinal.{max u v}

full_name: Ordinal.mex_not_mem_range
code: theorem mex_not_mem_range {ι : Type u} (f : ι → Ordinal.{max u v}) : mex.{_, v} f ∉ Set.range f 
goal: Ordinal.mex f ∉ Set.range f

full_name: Ordinal.le_mex_of_forall
code: theorem le_mex_of_forall {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal}
    (H : ∀ b < a, ∃ i, f i = b) : a ≤ mex.{_, v} f 
goal: a ≤ Ordinal.mex f

full_name: Ordinal.ne_mex
code: theorem ne_mex {ι : Type u} (f : ι → Ordinal.{max u v}) : ∀ i, f i ≠ mex.{_, v} f 
goal: f i ≠ Ordinal.mex f

full_name: Ordinal.mex_le_of_ne
code: theorem mex_le_of_ne {ι} {f : ι → Ordinal} {a} (ha : ∀ i, f i ≠ a) : mex f ≤ a 
goal: Ordinal.mex f ≤ a

full_name: Ordinal.exists_of_lt_mex
code: theorem exists_of_lt_mex {ι} {f : ι → Ordinal} {a} (ha : a < mex f) : ∃ i, f i = a 
goal: ∃ i, f i = a

full_name: Ordinal.mex_le_lsub
code: theorem mex_le_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) : mex.{_, v} f ≤ lsub.{_, v} f 
goal: Ordinal.mex f ≤ Ordinal.lsub f

full_name: Ordinal.mex_monotone
code: theorem mex_monotone {α β : Type u} {f : α → Ordinal.{max u v}} {g : β → Ordinal.{max u v}}
    (h : Set.range f ⊆ Set.range g) : mex.{_, v} f ≤ mex.{_, v} g 
goal: Ordinal.mex f ≤ Ordinal.mex g

full_name: Ordinal.mex_lt_ord_succ_mk
code: theorem mex_lt_ord_succ_mk {ι : Type u} (f : ι → Ordinal.{u}) :
    mex.{_, u} f < (succ #ι).ord 
goal: Ordinal.mex f < (Order.succ #ι).ord

full_name: Ordinal.bmex
code: /-- The minimum excluded ordinal of a family of ordinals indexed by the set of ordinals less than
    some `o : Ordinal.{u}`. This is a special case of `mex` over the family provided by
    `familyOfBFamily`.

    This is to `mex` as `bsup` is to `sup`. -/
def bmex (o : Ordinal) (f : ∀ a < o, Ordinal) : Ordinal 
goal: Ordinal.{max u_5 u_4}

full_name: Ordinal.bmex_not_mem_brange
code: theorem bmex_not_mem_brange {o : Ordinal} (f : ∀ a < o, Ordinal) : bmex o f ∉ brange o f 
goal: o.bmex f ∉ o.brange f

full_name: Ordinal.le_bmex_of_forall
code: theorem le_bmex_of_forall {o : Ordinal} (f : ∀ a < o, Ordinal) {a : Ordinal}
    (H : ∀ b < a, ∃ i hi, f i hi = b) : a ≤ bmex o f 
goal: a ≤ o.bmex f

full_name: Ordinal.ne_bmex
code: theorem ne_bmex {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) {i} (hi) :
    f i hi ≠ bmex.{_, v} o f 
goal: f i hi ≠ o.bmex f

full_name: Ordinal.bmex_le_of_ne
code: theorem bmex_le_of_ne {o : Ordinal} {f : ∀ a < o, Ordinal} {a} (ha : ∀ i hi, f i hi ≠ a) :
    bmex o f ≤ a 
goal: o.bmex f ≤ a

full_name: Ordinal.exists_of_lt_bmex
code: theorem exists_of_lt_bmex {o : Ordinal} {f : ∀ a < o, Ordinal} {a} (ha : a < bmex o f) :
    ∃ i hi, f i hi = a 
goal: ∃ i, ∃ (hi : i < o), f i hi = a

full_name: Ordinal.bmex_le_blsub
code: theorem bmex_le_blsub {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    bmex.{_, v} o f ≤ blsub.{_, v} o f 
goal: o.bmex f ≤ o.blsub f

full_name: Ordinal.bmex_monotone
code: theorem bmex_monotone {o o' : Ordinal.{u}}
    {f : ∀ a < o, Ordinal.{max u v}} {g : ∀ a < o', Ordinal.{max u v}}
    (h : brange o f ⊆ brange o' g) : bmex.{_, v} o f ≤ bmex.{_, v} o' g 
goal: o.bmex f ≤ o'.bmex g

full_name: Ordinal.bmex_lt_ord_succ_card
code: theorem bmex_lt_ord_succ_card {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{u}) :
    bmex.{_, u} o f < (succ o.card).ord 
goal: o.bmex f < (Order.succ o.card).ord

full_name: not_surjective_of_ordinal
code: theorem not_surjective_of_ordinal {α : Type u} (f : α → Ordinal.{u}) : ¬Surjective f 
goal: ¬Function.Surjective f

full_name: not_injective_of_ordinal
code: theorem not_injective_of_ordinal {α : Type u} (f : Ordinal.{u} → α) : ¬Injective f 
goal: ¬Function.Injective f

full_name: not_surjective_of_ordinal_of_small
code: theorem not_surjective_of_ordinal_of_small {α : Type v} [Small.{u} α] (f : α → Ordinal.{u}) :
    ¬Surjective f 
goal: ¬Function.Surjective f

full_name: not_injective_of_ordinal_of_small
code: theorem not_injective_of_ordinal_of_small {α : Type v} [Small.{u} α] (f : Ordinal.{u} → α) :
    ¬Injective f 
goal: ¬Function.Injective f

full_name: not_small_ordinal
code: /-- The type of ordinals in universe `u` is not `Small.{u}`. This is the type-theoretic analog of
the Burali-Forti paradox. -/
theorem not_small_ordinal : ¬Small.{u} Ordinal.{max u v} 
goal: ¬Small.{u, max (u + 1) (v + 1)} Ordinal.{max u v}

full_name: Ordinal.enumOrd
code: /-- Enumerator function for an unbounded set of ordinals. -/
def enumOrd (S : Set Ordinal.{u}) : Ordinal → Ordinal 
goal: Ordinal.{u} → Ordinal.{u}

full_name: Ordinal.enumOrd_def'
code: /-- The equation that characterizes `enumOrd` definitionally. This isn't the nicest expression to
    work with, so consider using `enumOrd_def` instead. -/
theorem enumOrd_def' (o) :
    enumOrd S o = sInf (S ∩ Set.Ici (blsub.{u, u} o fun a _ => enumOrd S a)) 
goal: Ordinal.enumOrd S o = sInf (S ∩ Set.Ici (o.blsub fun a x => Ordinal.enumOrd S a))

full_name: Ordinal.enumOrd_def'_nonempty
code: /-- The set in `enumOrd_def'` is nonempty. -/
theorem enumOrd_def'_nonempty (hS : Unbounded (· < ·) S) (a) : (S ∩ Set.Ici a).Nonempty 
goal: (S ∩ Set.Ici a).Nonempty

full_name: _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.enumOrd_mem_aux
code: private theorem enumOrd_mem_aux (hS : Unbounded (· < ·) S) (o) :
    enumOrd S o ∈ S ∩ Set.Ici (blsub.{u, u} o fun c _ => enumOrd S c) 
goal: Ordinal.enumOrd S o ∈ S ∩ Set.Ici (o.blsub fun c x => Ordinal.enumOrd S c)

full_name: Ordinal.enumOrd_mem
code: theorem enumOrd_mem (hS : Unbounded (· < ·) S) (o) : enumOrd S o ∈ S 
goal: Ordinal.enumOrd S o ∈ S

full_name: Ordinal.blsub_le_enumOrd
code: theorem blsub_le_enumOrd (hS : Unbounded (· < ·) S) (o) :
    (blsub.{u, u} o fun c _ => enumOrd S c) ≤ enumOrd S o 
goal: (o.blsub fun c x => Ordinal.enumOrd S c) ≤ Ordinal.enumOrd S o

full_name: Ordinal.enumOrd_strictMono
code: theorem enumOrd_strictMono (hS : Unbounded (· < ·) S) : StrictMono (enumOrd S) 
goal: StrictMono (Ordinal.enumOrd S)

full_name: Ordinal.enumOrd_def
code: /-- A more workable definition for `enumOrd`. -/
theorem enumOrd_def (o) : enumOrd S o = sInf (S ∩ { b | ∀ c, c < o → enumOrd S c < b }) 
goal: Ordinal.enumOrd S o = sInf (S ∩ {b | ∀ c < o, Ordinal.enumOrd S c < b})

full_name: Ordinal.enumOrd_def_nonempty
code: /-- The set in `enumOrd_def` is nonempty. -/
theorem enumOrd_def_nonempty (hS : Unbounded (· < ·) S) {o} :
    { x | x ∈ S ∧ ∀ c, c < o → enumOrd S c < x }.Nonempty 
goal: {x | x ∈ S ∧ ∀ c < o, Ordinal.enumOrd S c < x}.Nonempty

full_name: Ordinal.enumOrd_range
code: @[simp]
theorem enumOrd_range {f : Ordinal → Ordinal} (hf : StrictMono f) : enumOrd (range f) = f 
goal: Ordinal.enumOrd (Set.range f) = f

full_name: Ordinal.enumOrd_univ
code: @[simp]
theorem enumOrd_univ : enumOrd Set.univ = id 
goal: Ordinal.enumOrd Set.univ = id

full_name: Ordinal.enumOrd_zero
code: @[simp]
theorem enumOrd_zero : enumOrd S 0 = sInf S 
goal: Ordinal.enumOrd S 0 = sInf S

full_name: Ordinal.enumOrd_succ_le
code: theorem enumOrd_succ_le {a b} (hS : Unbounded (· < ·) S) (ha : a ∈ S) (hb : enumOrd S b < a) :
    enumOrd S (succ b) ≤ a 
goal: Ordinal.enumOrd S (Order.succ b) ≤ a

full_name: Ordinal.enumOrd_le_of_subset
code: theorem enumOrd_le_of_subset {S T : Set Ordinal} (hS : Unbounded (· < ·) S) (hST : S ⊆ T) (a) :
    enumOrd T a ≤ enumOrd S a 
goal: Ordinal.enumOrd T a ≤ Ordinal.enumOrd S a

full_name: Ordinal.enumOrd_surjective
code: theorem enumOrd_surjective (hS : Unbounded (· < ·) S) : ∀ s ∈ S, ∃ a, enumOrd S a = s 
goal: s ∈ S → ∃ a, Ordinal.enumOrd S a = s

full_name: Ordinal.enumOrdOrderIso
code: /-- An order isomorphism between an unbounded set of ordinals and the ordinals. -/
def enumOrdOrderIso (hS : Unbounded (· < ·) S) : Ordinal ≃o S 
goal: Ordinal.{u} ≃o ↑S

full_name: Ordinal.range_enumOrd
code: theorem range_enumOrd (hS : Unbounded (· < ·) S) : range (enumOrd S) = S 
goal: Set.range (Ordinal.enumOrd S) = S

full_name: Ordinal.eq_enumOrd
code: /-- A characterization of `enumOrd`: it is the unique strict monotonic function with range `S`. -/
theorem eq_enumOrd (f : Ordinal → Ordinal) (hS : Unbounded (· < ·) S) :
    StrictMono f ∧ range f = S ↔ f = enumOrd S 
goal: StrictMono f ∧ Set.range f = S ↔ f = Ordinal.enumOrd S

full_name: Ordinal.one_add_natCast
code: @[simp]
theorem one_add_natCast (m : ℕ) : 1 + (m : Ordinal) = succ m 
goal: 1 + ↑m = ↑(Order.succ m)

full_name: Ordinal.one_add_ofNat
code: @[simp]
theorem one_add_ofNat (m : ℕ) [m.AtLeastTwo] :
    1 + (no_index (OfNat.ofNat m : Ordinal)) = Order.succ (OfNat.ofNat m : Ordinal) 
goal: 1 + OfNat.ofNat m = Order.succ (OfNat.ofNat m)

full_name: Ordinal.natCast_mul
code: @[simp, norm_cast]
theorem natCast_mul (m : ℕ) : ∀ n : ℕ, ((m * n : ℕ) : Ordinal) = m * n
  
goal: ↑(m * n) = ↑m * ↑n

full_name: Ordinal.natCast_le
code: /-- Alias of `Nat.cast_le`, specialized to `Ordinal` --/
theorem natCast_le {m n : ℕ} : (m : Ordinal) ≤ n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: Ordinal.natCast_inj
code: /-- Alias of `Nat.cast_inj`, specialized to `Ordinal` --/
theorem natCast_inj {m n : ℕ} : (m : Ordinal) = n ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: Ordinal.charZero
code: instance charZero : CharZero Ordinal 
goal: CharZero Ordinal.{u_1}

full_name: Ordinal.natCast_lt
code: /-- Alias of `Nat.cast_lt`, specialized to `Ordinal` --/
theorem natCast_lt {m n : ℕ} : (m : Ordinal) < n ↔ m < n 
goal: ↑m < ↑n ↔ m < n

full_name: Ordinal.natCast_eq_zero
code: /-- Alias of `Nat.cast_eq_zero`, specialized to `Ordinal` --/
theorem natCast_eq_zero {n : ℕ} : (n : Ordinal) = 0 ↔ n = 0 
goal: ↑n = 0 ↔ n = 0

full_name: Ordinal.natCast_ne_zero
code: /-- Alias of `Nat.cast_eq_zero`, specialized to `Ordinal` --/
theorem natCast_ne_zero {n : ℕ} : (n : Ordinal) ≠ 0 ↔ n ≠ 0 
goal: ↑n ≠ 0 ↔ n ≠ 0

full_name: Ordinal.natCast_pos
code: /-- Alias of `Nat.cast_pos'`, specialized to `Ordinal` --/
theorem natCast_pos {n : ℕ} : (0 : Ordinal) < n ↔ 0 < n 
goal: 0 < ↑n ↔ 0 < n

full_name: Ordinal.natCast_sub
code: @[simp, norm_cast]
theorem natCast_sub (m n : ℕ) : ((m - n : ℕ) : Ordinal) = m - n 
goal: ↑(m - n) = ↑m - ↑n

full_name: Ordinal.natCast_div
code: @[simp, norm_cast]
theorem natCast_div (m n : ℕ) : ((m / n : ℕ) : Ordinal) = m / n 
goal: ↑(m / n) = ↑m / ↑n

full_name: Ordinal.natCast_mod
code: @[simp, norm_cast]
theorem natCast_mod (m n : ℕ) : ((m % n : ℕ) : Ordinal) = m % n 
goal: ↑(m % n) = ↑m % ↑n

full_name: Ordinal.lift_natCast
code: @[simp]
theorem lift_natCast : ∀ n : ℕ, lift.{u, v} n = n
  
goal: Ordinal.lift.{u, v} ↑n = ↑n

full_name: Ordinal.lift_ofNat
code: @[simp]
theorem lift_ofNat (n : ℕ) [n.AtLeastTwo] :
    lift.{u, v} (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
goal: Ordinal.lift.{u, v} (OfNat.ofNat n) = OfNat.ofNat n

full_name: Cardinal.ord_aleph0
code: @[simp]
theorem ord_aleph0 : ord.{u} ℵ₀ = ω 
goal: ℵ₀.ord = ω

full_name: Cardinal.add_one_of_aleph0_le
code: @[simp]
theorem add_one_of_aleph0_le {c} (h : ℵ₀ ≤ c) : c + 1 = c 
goal: c + 1 = c

full_name: Ordinal.lt_add_of_limit
code: theorem lt_add_of_limit {a b c : Ordinal.{u}} (h : IsLimit c) :
    a < b + c ↔ ∃ c' < c, a < b + c' 
goal: a < b + c ↔ ∃ c' < c, a < b + c'

full_name: Ordinal.lt_omega
code: theorem lt_omega {o : Ordinal} : o < ω ↔ ∃ n : ℕ, o = n 
goal: o < ω ↔ ∃ n, o = ↑n

full_name: Ordinal.nat_lt_omega
code: theorem nat_lt_omega (n : ℕ) : ↑n < ω 
goal: ↑n < ω

full_name: Ordinal.omega_pos
code: theorem omega_pos : 0 < ω 
goal: 0 < ω

full_name: Ordinal.omega_ne_zero
code: theorem omega_ne_zero : ω ≠ 0 
goal: ω ≠ 0

full_name: Ordinal.one_lt_omega
code: theorem one_lt_omega : 1 < ω 
goal: 1 < ω

full_name: Ordinal.omega_isLimit
code: theorem omega_isLimit : IsLimit ω 
goal: ω.IsLimit

full_name: Ordinal.omega_le
code: theorem omega_le {o : Ordinal} : ω ≤ o ↔ ∀ n : ℕ, ↑n ≤ o 
goal: ω ≤ o ↔ ∀ (n : ℕ), ↑n ≤ o

full_name: Ordinal.sup_natCast
code: @[simp]
theorem sup_natCast : sup Nat.cast = ω 
goal: Ordinal.sup Nat.cast = ω

full_name: Ordinal.nat_lt_limit
code: theorem nat_lt_limit {o} (h : IsLimit o) : ∀ n : ℕ, ↑n < o
  
goal: ↑n < o

full_name: Ordinal.omega_le_of_isLimit
code: theorem omega_le_of_isLimit {o} (h : IsLimit o) : ω ≤ o 
goal: ω ≤ o

full_name: Ordinal.isLimit_iff_omega_dvd
code: theorem isLimit_iff_omega_dvd {a : Ordinal} : IsLimit a ↔ a ≠ 0 ∧ ω ∣ a 
goal: a.IsLimit ↔ a ≠ 0 ∧ ω ∣ a

full_name: Ordinal.add_mul_limit_aux
code: theorem add_mul_limit_aux {a b c : Ordinal} (ba : b + a = a) (l : IsLimit c)
    (IH : ∀ c' < c, (a + b) * succ c' = a * succ c' + b) : (a + b) * c = a * c 
goal: (a + b) * c = a * c

full_name: Ordinal.add_mul_succ
code: theorem add_mul_succ {a b : Ordinal} (c) (ba : b + a = a) : (a + b) * succ c = a * succ c + b 
goal: (a + b) * Order.succ c = a * Order.succ c + b

full_name: Ordinal.add_mul_limit
code: theorem add_mul_limit {a b c : Ordinal} (ba : b + a = a) (l : IsLimit c) : (a + b) * c = a * c 
goal: (a + b) * c = a * c

full_name: Ordinal.add_le_of_forall_add_lt
code: theorem add_le_of_forall_add_lt {a b c : Ordinal} (hb : 0 < b) (h : ∀ d < b, a + d < c) :
    a + b ≤ c 
goal: a + b ≤ c

full_name: Ordinal.IsNormal.apply_omega
code: theorem IsNormal.apply_omega {f : Ordinal.{u} → Ordinal.{u}} (hf : IsNormal f) :
    Ordinal.sup.{0, u} (f ∘ Nat.cast) = f ω 
goal: Ordinal.sup (f ∘ Nat.cast) = f ω

full_name: Ordinal.sup_add_nat
code: @[simp]
theorem sup_add_nat (o : Ordinal) : (sup fun n : ℕ => o + n) = o + ω 
goal: (Ordinal.sup fun n => o + ↑n) = o + ω

full_name: Ordinal.sup_mul_nat
code: @[simp]
theorem sup_mul_nat (o : Ordinal) : (sup fun n : ℕ => o * n) = o * ω 
goal: (Ordinal.sup fun n => o * ↑n) = o * ω

full_name: Acc.rank
code: /-- The rank of an element `a` accessible under a relation `r` is defined inductively as the
smallest ordinal greater than the ranks of all elements below it (i.e. elements `b` such that
`r b a`). -/
noncomputable def rank (h : Acc r a) : Ordinal.{u} 
goal: Ordinal.{u}

full_name: Acc.rank_eq
code: theorem rank_eq (h : Acc r a) :
    h.rank = Ordinal.sup.{u, u} fun b : { b // r b a } => Order.succ (h.inv b.2).rank 
goal: h.rank = Ordinal.sup fun b => Order.succ ⋯.rank

full_name: Acc.rank_lt_of_rel
code: /-- if `r a b` then the rank of `a` is less than the rank of `b`. -/
theorem rank_lt_of_rel (hb : Acc r b) (h : r a b) : (hb.inv h).rank < hb.rank 
goal: ⋯.rank < hb.rank

full_name: WellFounded.rank
code: /-- The rank of an element `a` under a well-founded relation `r` is defined inductively as the
smallest ordinal greater than the ranks of all elements below it (i.e. elements `b` such that
`r b a`). -/
noncomputable def rank (a : α) : Ordinal.{u} 
goal: Ordinal.{u}

full_name: WellFounded.rank_eq
code: theorem rank_eq :
    hwf.rank a = Ordinal.sup.{u, u} fun b : { b // r b a } => Order.succ <| hwf.rank b 
goal: hwf.rank a = Ordinal.sup fun b => Order.succ (hwf.rank ↑b)

full_name: WellFounded.rank_lt_of_rel
code: theorem rank_lt_of_rel (h : r a b) : hwf.rank a < hwf.rank b 
goal: hwf.rank a < hwf.rank b

full_name: WellFounded.rank_strictMono
code: theorem rank_strictMono [Preorder α] [WellFoundedLT α] :
    StrictMono (rank <| @wellFounded_lt α _ _) 
goal: StrictMono ⋯.rank

full_name: WellFounded.rank_strictAnti
code: theorem rank_strictAnti [Preorder α] [WellFoundedGT α] :
    StrictAnti (rank <| @wellFounded_gt α _ _) 
goal: StrictAnti ⋯.rank