ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ordinal.mul_pos
theorem mul_pos {a b : Ordinal} (h₁ : 0 < a) (h₂ : 0 < b) : 0 < a * b 
Arguments: {a b : Ordinal.{u_4}} (h₁ : 0 < a) (h₂ : 0 < b)
Goal: 0 < a * b
-- Ordinal.mul_ne_zero
theorem mul_ne_zero {a b : Ordinal} : a ≠ 0 → b ≠ 0 → a * b ≠ 0 
Arguments: {a b : Ordinal.{u_4}}
Goal: a ≠ 0 → b ≠ 0 → a * b ≠ 0
-- Ordinal.le_of_mul_le_mul_left
theorem le_of_mul_le_mul_left {a b c : Ordinal} (h : c * a ≤ c * b) (h0 : 0 < c) : a ≤ b 
Arguments: {a b c : Ordinal.{u_4}} (h : c * a ≤ c * b) (h0 : 0 < c)
Goal: a ≤ b
-- Ordinal.mul_right_inj
theorem mul_right_inj {a b c : Ordinal} (a0 : 0 < a) : a * b = a * c ↔ b = c 
Arguments: {a b c : Ordinal.{u_4}} (a0 : 0 < a)
Goal: a * b = a * c ↔ b = c
-- Ordinal.mul_isLimit
theorem mul_isLimit {a b : Ordinal} (a0 : 0 < a) : IsLimit b → IsLimit (a * b) 
Arguments: {a b : Ordinal.{u_4}} (a0 : 0 < a)
Goal: b.IsLimit → (a * b).IsLimit
-- Ordinal.mul_isLimit_left
theorem mul_isLimit_left {a b : Ordinal} (l : IsLimit a) (b0 : 0 < b) : IsLimit (a * b) 
Arguments: {a b : Ordinal.{u_4}} (l : a.IsLimit) (b0 : 0 < b)
Goal: (a * b).IsLimit
-- Ordinal.smul_eq_mul
theorem smul_eq_mul : ∀ (n : ℕ) (a : Ordinal), n • a = a * n
  
Arguments: (n : ℕ) (a : Ordinal.{u_4})
Goal: n • a = a * ↑n
-- Ordinal.div_nonempty
theorem div_nonempty {a b : Ordinal} (h : b ≠ 0) : { o | a < b * succ o }.Nonempty 
Arguments: {a b : Ordinal.{u_4}} (h : b ≠ 0)
Goal: {o | a < b * Order.succ o}.Nonempty
-- Ordinal.div_zero
@[simp]
theorem div_zero (a : Ordinal) : a / 0 = 0 
Arguments: (a : Ordinal.{u_4})
Goal: a / 0 = 0
-- Ordinal.div_def
theorem div_def (a) {b : Ordinal} (h : b ≠ 0) : a / b = sInf { o | a < b * succ o } 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}} (h : b ≠ 0)
Goal: a / b = sInf {o | a < b * Order.succ o}
-- Ordinal.lt_mul_succ_div
theorem lt_mul_succ_div (a) {b : Ordinal} (h : b ≠ 0) : a < b * succ (a / b) 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}} (h : b ≠ 0)
Goal: a < b * Order.succ (a / b)
-- Ordinal.lt_mul_div_add
theorem lt_mul_div_add (a) {b : Ordinal} (h : b ≠ 0) : a < b * (a / b) + b 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}} (h : b ≠ 0)
Goal: a < b * (a / b) + b
-- Ordinal.div_le
theorem div_le {a b c : Ordinal} (b0 : b ≠ 0) : a / b ≤ c ↔ a < b * succ c 
Arguments: {a b c : Ordinal.{u_4}} (b0 : b ≠ 0)
Goal: a / b ≤ c ↔ a < b * Order.succ c
-- Ordinal.lt_div
theorem lt_div {a b c : Ordinal} (h : c ≠ 0) : a < b / c ↔ c * succ a ≤ b 
Arguments: {a b c : Ordinal.{u_4}} (h : c ≠ 0)
Goal: a < b / c ↔ c * Order.succ a ≤ b
-- Ordinal.div_pos
theorem div_pos {b c : Ordinal} (h : c ≠ 0) : 0 < b / c ↔ c ≤ b 
Arguments: {b c : Ordinal.{u_4}} (h : c ≠ 0)
Goal: 0 < b / c ↔ c ≤ b
-- Ordinal.le_div
theorem le_div {a b c : Ordinal} (c0 : c ≠ 0) : a ≤ b / c ↔ c * a ≤ b 
Arguments: {a b c : Ordinal.{u_4}} (c0 : c ≠ 0)
Goal: a ≤ b / c ↔ c * a ≤ b
-- Ordinal.div_lt
theorem div_lt {a b c : Ordinal} (b0 : b ≠ 0) : a / b < c ↔ a < b * c 
Arguments: {a b c : Ordinal.{u_4}} (b0 : b ≠ 0)
Goal: a / b < c ↔ a < b * c
-- Ordinal.div_le_of_le_mul
theorem div_le_of_le_mul {a b c : Ordinal} (h : a ≤ b * c) : a / b ≤ c 
Arguments: {a b c : Ordinal.{u_4}} (h : a ≤ b * c)
Goal: a / b ≤ c
-- Ordinal.mul_lt_of_lt_div
theorem mul_lt_of_lt_div {a b c : Ordinal} : a < b / c → c * a < b 
Arguments: {a b c : Ordinal.{u_4}}
Goal: a < b / c → c * a < b
-- Ordinal.zero_div
@[simp]
theorem zero_div (a : Ordinal) : 0 / a = 0 
Arguments: (a : Ordinal.{u_4})
Goal: 0 / a = 0
-- Ordinal.mul_div_le
theorem mul_div_le (a b : Ordinal) : b * (a / b) ≤ a 
Arguments: (a b : Ordinal.{u_4})
Goal: b * (a / b) ≤ a
-- Ordinal.mul_add_div
theorem mul_add_div (a) {b : Ordinal} (b0 : b ≠ 0) (c) : (b * a + c) / b = a + c / b 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}} (b0 : b ≠ 0) (c : Ordinal.{u_4})
Goal: (b * a + c) / b = a + c / b
-- Ordinal.div_eq_zero_of_lt
theorem div_eq_zero_of_lt {a b : Ordinal} (h : a < b) : a / b = 0 
Arguments: {a b : Ordinal.{u_4}} (h : a < b)
Goal: a / b = 0
-- Ordinal.mul_div_cancel
@[simp]
theorem mul_div_cancel (a) {b : Ordinal} (b0 : b ≠ 0) : b * a / b = a 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}} (b0 : b ≠ 0)
Goal: b * a / b = a
-- Ordinal.div_one
@[simp]
theorem div_one (a : Ordinal) : a / 1 = a 
Arguments: (a : Ordinal.{u_4})
Goal: a / 1 = a
-- Ordinal.div_self
@[simp]
theorem div_self {a : Ordinal} (h : a ≠ 0) : a / a = 1 
Arguments: {a : Ordinal.{u_4}} (h : a ≠ 0)
Goal: a / a = 1
-- Ordinal.mul_sub
theorem mul_sub (a b c : Ordinal) : a * (b - c) = a * b - a * c 
Arguments: (a b c : Ordinal.{u_4})
Goal: a * (b - c) = a * b - a * c
-- Ordinal.isLimit_add_iff
theorem isLimit_add_iff {a b} : IsLimit (a + b) ↔ IsLimit b ∨ b = 0 ∧ IsLimit a 
Arguments: {a b : Ordinal.{u_4}}
Goal: (a + b).IsLimit ↔ b.IsLimit ∨ b = 0 ∧ a.IsLimit
-- Ordinal.dvd_add_iff
theorem dvd_add_iff : ∀ {a b c : Ordinal}, a ∣ b → (a ∣ b + c ↔ a ∣ c)
  
Arguments: {a b c : Ordinal.{u_4}}
Goal: a ∣ b → (a ∣ b + c ↔ a ∣ c)
-- Ordinal.div_mul_cancel
theorem div_mul_cancel : ∀ {a b : Ordinal}, a ≠ 0 → a ∣ b → a * (b / a) = b
  
Arguments: {a b : Ordinal.{u_4}}
Goal: a ≠ 0 → a ∣ b → a * (b / a) = b
-- Ordinal.le_of_dvd
theorem le_of_dvd : ∀ {a b : Ordinal}, b ≠ 0 → a ∣ b → a ≤ b
  -- Porting note: `⟨b, rfl⟩ => by` → `⟨b, e⟩ => by subst e`
  
Arguments: {a b : Ordinal.{u_4}}
Goal: b ≠ 0 → a ∣ b → a ≤ b
-- Ordinal.dvd_antisymm
theorem dvd_antisymm {a b : Ordinal} (h₁ : a ∣ b) (h₂ : b ∣ a) : a = b 
Arguments: {a b : Ordinal.{u_4}} (h₁ : a ∣ b) (h₂ : b ∣ a)
Goal: a = b
-- Ordinal.mod_def
theorem mod_def (a b : Ordinal) : a % b = a - b * (a / b) 
Arguments: (a b : Ordinal.{u_4})
Goal: a % b = a - b * (a / b)
-- Ordinal.mod_le
theorem mod_le (a b : Ordinal) : a % b ≤ a 
Arguments: (a b : Ordinal.{u_4})
Goal: a % b ≤ a
-- Ordinal.mod_zero
@[simp]
theorem mod_zero (a : Ordinal) : a % 0 = a 
Arguments: (a : Ordinal.{u_4})
Goal: a % 0 = a
-- Ordinal.mod_eq_of_lt
theorem mod_eq_of_lt {a b : Ordinal} (h : a < b) : a % b = a 
Arguments: {a b : Ordinal.{u_4}} (h : a < b)
Goal: a % b = a
-- Ordinal.zero_mod
@[simp]
theorem zero_mod (b : Ordinal) : 0 % b = 0 
Arguments: (b : Ordinal.{u_4})
Goal: 0 % b = 0
-- Ordinal.div_add_mod
theorem div_add_mod (a b : Ordinal) : b * (a / b) + a % b = a 
Arguments: (a b : Ordinal.{u_4})
Goal: b * (a / b) + a % b = a
-- Ordinal.mod_lt
theorem mod_lt (a) {b : Ordinal} (h : b ≠ 0) : a % b < b 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}} (h : b ≠ 0)
Goal: a % b < b
-- Ordinal.mod_self
@[simp]
theorem mod_self (a : Ordinal) : a % a = 0 
Arguments: (a : Ordinal.{u_4})
Goal: a % a = 0
-- Ordinal.mod_one
@[simp]
theorem mod_one (a : Ordinal) : a % 1 = 0 
Arguments: (a : Ordinal.{u_4})
Goal: a % 1 = 0
-- Ordinal.dvd_of_mod_eq_zero
theorem dvd_of_mod_eq_zero {a b : Ordinal} (H : a % b = 0) : b ∣ a 
Arguments: {a b : Ordinal.{u_4}} (H : a % b = 0)
Goal: b ∣ a
-- Ordinal.mod_eq_zero_of_dvd
theorem mod_eq_zero_of_dvd {a b : Ordinal} (H : b ∣ a) : a % b = 0 
Arguments: {a b : Ordinal.{u_4}} (H : b ∣ a)
Goal: a % b = 0
-- Ordinal.dvd_iff_mod_eq_zero
theorem dvd_iff_mod_eq_zero {a b : Ordinal} : b ∣ a ↔ a % b = 0 
Arguments: {a b : Ordinal.{u_4}}
Goal: b ∣ a ↔ a % b = 0
-- Ordinal.mul_add_mod_self
@[simp]
theorem mul_add_mod_self (x y z : Ordinal) : (x * y + z) % x = z % x 
Arguments: (x y z : Ordinal.{u_4})
Goal: (x * y + z) % x = z % x
-- Ordinal.mul_mod
@[simp]
theorem mul_mod (x y : Ordinal) : x * y % x = 0 
Arguments: (x y : Ordinal.{u_4})
Goal: x * y % x = 0
-- Ordinal.mod_mod_of_dvd
theorem mod_mod_of_dvd (a : Ordinal) {b c : Ordinal} (h : c ∣ b) : a % b % c = a % c 
Arguments: (a : Ordinal.{u_4}) {b c : Ordinal.{u_4}} (h : c ∣ b)
Goal: a % b % c = a % c
-- Ordinal.mod_mod
@[simp]
theorem mod_mod (a b : Ordinal) : a % b % b = a % b 
Arguments: (a b : Ordinal.{u_4})
Goal: a % b % b = a % b
-- Ordinal.bfamilyOfFamily'_typein
@[simp]
theorem bfamilyOfFamily'_typein {ι} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) (i) :
    bfamilyOfFamily' r f (typein r i) (typein_lt_type r i) = f i 
Arguments: {α : Type u_1} {ι : Type u_4} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) (i : ι)
Goal: Ordinal.bfamilyOfFamily' r f (Ordinal.typein r i) ⋯ = f i
-- Ordinal.bfamilyOfFamily_typein
@[simp]
theorem bfamilyOfFamily_typein {ι} (f : ι → α) (i) :
    bfamilyOfFamily f (typein _ i) (typein_lt_type _ i) = f i 
Arguments: {α : Type u_1} {ι : Type u_4} (f : ι → α) (i : ι)
Goal: Ordinal.bfamilyOfFamily f (Ordinal.typein WellOrderingRel i) ⋯ = f i
-- Ordinal.familyOfBFamily'_enum
@[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 
Arguments: {α : Type u_1} {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o : Ordinal.{u}} (ho : Ordinal.type r = o) (f : (a : Ordinal.{u}) → a < o → α) (i : Ordinal.{u}) (hi : i < o)
Goal: Ordinal.familyOfBFamily' r ho f (Ordinal.enum r i ⋯) = f i hi
-- Ordinal.familyOfBFamily_enum
@[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 
Arguments: {α : Type u_1} (o : Ordinal.{u_4}) (f : (a : Ordinal.{u_4}) → a < o → α) (i : Ordinal.{u_4}) (hi : i < o)
Goal: o.familyOfBFamily f (Ordinal.enum (fun x x_1 => x < x_1) i ⋯) = f i hi
-- Ordinal.mem_brange
theorem mem_brange {o : Ordinal} {f : ∀ a < o, α} {a} : a ∈ brange o f ↔ ∃ i hi, f i hi = a 
Arguments: {α : Type u_1} {o : Ordinal.{u_4}} {f : (a : Ordinal.{u_4}) → a < o → α} {a : α}
Goal: a ∈ o.brange f ↔ ∃ i, ∃ (hi : i < o), f i hi = a
-- Ordinal.mem_brange_self
theorem mem_brange_self {o} (f : ∀ a < o, α) (i hi) : f i hi ∈ brange o f 
Arguments: {α : Type u_1} {o : Ordinal.{u_4}} (f : (a : Ordinal.{u_4}) → a < o → α) (i : Ordinal.{u_4}) (hi : i < o)
Goal: f i hi ∈ o.brange f
-- Ordinal.range_familyOfBFamily'
@[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 
Arguments: {α : Type u_1} {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o : Ordinal.{u}} (ho : Ordinal.type r = o) (f : (a : Ordinal.{u}) → a < o → α)
Goal: Set.range (Ordinal.familyOfBFamily' r ho f) = o.brange f
-- Ordinal.range_familyOfBFamily
@[simp]
theorem range_familyOfBFamily {o} (f : ∀ a < o, α) : range (familyOfBFamily o f) = brange o f 
Arguments: {α : Type u_1} {o : Ordinal.{u_4}} (f : (a : Ordinal.{u_4}) → a < o → α)
Goal: Set.range (o.familyOfBFamily f) = o.brange f
-- Ordinal.brange_bfamilyOfFamily'
@[simp]
theorem brange_bfamilyOfFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) :
    brange _ (bfamilyOfFamily' r f) = range f 
Arguments: {α : Type u_1} {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α)
Goal: (Ordinal.type r).brange (Ordinal.bfamilyOfFamily' r f) = Set.range f
-- Ordinal.brange_bfamilyOfFamily
@[simp]
theorem brange_bfamilyOfFamily {ι : Type u} (f : ι → α) : brange _ (bfamilyOfFamily f) = range f 
Arguments: {α : Type u_1} {ι : Type u} (f : ι → α)
Goal: (Ordinal.type WellOrderingRel).brange (Ordinal.bfamilyOfFamily f) = Set.range f
-- Ordinal.brange_const
@[simp]
theorem brange_const {o : Ordinal} (ho : o ≠ 0) {c : α} : (brange o fun _ _ => c) = {c} 
Arguments: {α : Type u_1} {o : Ordinal.{u_4}} (ho : o ≠ 0) {c : α}
Goal: (o.brange fun x x => c) = {c}
-- Ordinal.comp_bfamilyOfFamily'
theorem comp_bfamilyOfFamily' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α)
    (g : α → β) : (fun i hi => g (bfamilyOfFamily' r f i hi)) = bfamilyOfFamily' r (g ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → α) (g : α → β)
Goal: (fun i hi => g (Ordinal.bfamilyOfFamily' r f i hi)) = Ordinal.bfamilyOfFamily' r (g ∘ f)
-- Ordinal.comp_bfamilyOfFamily
theorem comp_bfamilyOfFamily {ι : Type u} (f : ι → α) (g : α → β) :
    (fun i hi => g (bfamilyOfFamily f i hi)) = bfamilyOfFamily (g ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Type u} (f : ι → α) (g : α → β)
Goal: (fun i hi => g (Ordinal.bfamilyOfFamily f i hi)) = Ordinal.bfamilyOfFamily (g ∘ f)
-- Ordinal.comp_familyOfBFamily'
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) 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] {o : Ordinal.{u}} (ho : Ordinal.type r = o) (f : (a : Ordinal.{u}) → a < o → α) (g : α → β)
Goal: g ∘ Ordinal.familyOfBFamily' r ho f = Ordinal.familyOfBFamily' r ho fun i hi => g (f i hi)
-- Ordinal.comp_familyOfBFamily
theorem comp_familyOfBFamily {o} (f : ∀ a < o, α) (g : α → β) :
    g ∘ familyOfBFamily o f = familyOfBFamily o fun i hi => g (f i hi) 
Arguments: {α : Type u_1} {β : Type u_2} {o : Ordinal.{u_4}} (f : (a : Ordinal.{u_4}) → a < o → α) (g : α → β)
Goal: g ∘ o.familyOfBFamily f = o.familyOfBFamily fun i hi => g (f i hi)
-- Ordinal.sSup_eq_sup
@[simp]
theorem sSup_eq_sup {ι : Type u} (f : ι → Ordinal.{max u v}) : sSup (Set.range f) = sup.{_, v} f 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v})
Goal: sSup (Set.range f) = Ordinal.sup f
-- Ordinal.bddAbove_range
theorem bddAbove_range {ι : Type u} (f : ι → Ordinal.{max u v}) : BddAbove (Set.range f) 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v})
Goal: BddAbove (Set.range f)
-- Ordinal.le_sup
theorem le_sup {ι : Type u} (f : ι → Ordinal.{max u v}) : ∀ i, f i ≤ sup.{_, v} f 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v}) (i : ι)
Goal: f i ≤ Ordinal.sup f
-- Ordinal.sup_le_iff
theorem sup_le_iff {ι : Type u} {f : ι → Ordinal.{max u v}} {a} : sup.{_, v} f ≤ a ↔ ∀ i, f i ≤ a 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal.{max u v}}
Goal: Ordinal.sup f ≤ a ↔ ∀ (i : ι), f i ≤ a
-- Ordinal.sup_le
theorem sup_le {ι : Type u} {f : ι → Ordinal.{max u v}} {a} : (∀ i, f i ≤ a) → sup.{_, v} f ≤ a 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal.{max u v}}
Goal: (∀ (i : ι), f i ≤ a) → Ordinal.sup f ≤ a
-- Ordinal.lt_sup
theorem lt_sup {ι : Type u} {f : ι → Ordinal.{max u v}} {a} : a < sup.{_, v} f ↔ ∃ i, a < f i 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v}} {a : Ordinal.{max u v}}
Goal: a < Ordinal.sup f ↔ ∃ i, a < f i
-- Ordinal.ne_sup_iff_lt_sup
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 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v}}
Goal: (∀ (i : ι), f i ≠ Ordinal.sup f) ↔ ∀ (i : ι), f i < Ordinal.sup f
-- Ordinal.sup_not_succ_of_ne_sup
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 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v}} (hf : ∀ (i : ι), f i ≠ Ordinal.sup f) {a : Ordinal.{max u v}} (hao : a < Ordinal.sup f)
Goal: Order.succ a < Ordinal.sup f
-- Ordinal.sup_eq_zero_iff
@[simp]
theorem sup_eq_zero_iff {ι : Type u} {f : ι → Ordinal.{max u v}} :
    sup.{_, v} f = 0 ↔ ∀ i, f i = 0 
Arguments: {ι : Type u} {f : ι → Ordinal.{max u v}}
Goal: Ordinal.sup f = 0 ↔ ∀ (i : ι), f i = 0
-- Ordinal.IsNormal.sup
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) 
Arguments: {f : Ordinal.{max u v} → Ordinal.{max u w}} (H : Ordinal.IsNormal f) {ι : Type u} (g : ι → Ordinal.{max u v}) [Nonempty ι]
Goal: f (Ordinal.sup g) = Ordinal.sup (f ∘ g)
-- Ordinal.sup_empty
@[simp]
theorem sup_empty {ι} [IsEmpty ι] (f : ι → Ordinal) : sup f = 0 
Arguments: {ι : Type u_4} [IsEmpty ι] (f : ι → Ordinal.{max u_5 u_4})
Goal: Ordinal.sup f = 0
-- Ordinal.sup_const
@[simp]
theorem sup_const {ι} [_hι : Nonempty ι] (o : Ordinal) : (sup fun _ : ι => o) = o 
Arguments: {ι : Type u_4} [_hι : Nonempty ι] (o : Ordinal.{max u_5 u_4})
Goal: (Ordinal.sup fun x => o) = o
-- Ordinal.sup_unique
@[simp]
theorem sup_unique {ι} [Unique ι] (f : ι → Ordinal) : sup f = f default 
Arguments: {ι : Type u_4} [Unique ι] (f : ι → Ordinal.{max u_5 u_4})
Goal: Ordinal.sup f = f default
-- Ordinal.sup_le_of_range_subset
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 
Arguments: {ι : Type u} {ι' : Type v} {f : ι → Ordinal.{max (max u v) w}} {g : ι' → Ordinal.{max (max u v) w}} (h : Set.range f ⊆ Set.range g)
Goal: Ordinal.sup f ≤ Ordinal.sup g
-- Ordinal.sup_eq_of_range_eq
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 
Arguments: {ι : Type u} {ι' : Type v} {f : ι → Ordinal.{max (max u v) w}} {g : ι' → Ordinal.{max (max u v) w}} (h : Set.range f = Set.range g)
Goal: Ordinal.sup f = Ordinal.sup g
-- Ordinal.sup_sum
@[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)) 
Arguments: {α : Type u} {β : Type v} (f : α ⊕ β → Ordinal.{max (max u v) w})
Goal: Ordinal.sup f = max (Ordinal.sup fun a => f (Sum.inl a)) (Ordinal.sup fun b => f (Sum.inr b))
-- Ordinal.unbounded_range_of_sup_ge
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) 
Arguments: {α β : Type u} (r : α → α → Prop) [IsWellOrder α r] (f : β → α) (h : Ordinal.type r ≤ Ordinal.sup (Ordinal.typein r ∘ f))
Goal: Set.Unbounded r (Set.range f)
-- Ordinal.le_sup_shrink_equiv
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 
Arguments: {s : Set Ordinal.{u}} (hs : Small.{u, u + 1} ↑s) (a : Ordinal.{u}) (ha : a ∈ s)
Goal: a ≤ Ordinal.sup fun x => ↑((equivShrink ↑s).symm x)
-- Ordinal.bddAbove_iff_small
theorem bddAbove_iff_small {s : Set Ordinal.{u}} : BddAbove s ↔ Small.{u} s 
Arguments: {s : Set Ordinal.{u}}
Goal: BddAbove s ↔ Small.{u, u + 1} ↑s
-- Ordinal.bddAbove_of_small
theorem bddAbove_of_small (s : Set Ordinal.{u}) [h : Small.{u} s] : BddAbove s 
Arguments: (s : Set Ordinal.{u}) [h : Small.{u, u + 1} ↑s]
Goal: BddAbove s
-- Ordinal.sup_eq_sSup
theorem sup_eq_sSup {s : Set Ordinal.{u}} (hs : Small.{u} s) :
    (sup.{u, u} fun x => (@equivShrink s hs).symm x) = sSup s 
Arguments: {s : Set Ordinal.{u}} (hs : Small.{u, u + 1} ↑s)
Goal: (Ordinal.sup fun x => ↑((equivShrink ↑s).symm x)) = sSup s
-- Ordinal.sSup_ord
theorem sSup_ord {s : Set Cardinal.{u}} (hs : BddAbove s) : (sSup s).ord = sSup (ord '' s) 
Arguments: {s : Set Cardinal.{u}} (hs : BddAbove s)
Goal: (sSup s).ord = sSup (Cardinal.ord '' s)
-- Ordinal.iSup_ord
theorem iSup_ord {ι} {f : ι → Cardinal} (hf : BddAbove (range f)) :
    (iSup f).ord = ⨆ i, (f i).ord 
Arguments: {ι : Sort u_4} {f : ι → Cardinal.{u_5}} (hf : BddAbove (Set.range f))
Goal: (iSup f).ord = ⨆ i, (f i).ord
-- _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.sup_le_sup
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) 
Arguments: {ι ι' : Type u} (r : ι → ι → Prop) (r' : ι' → ι' → Prop) [IsWellOrder ι r] [IsWellOrder ι' r'] {o : Ordinal.{u}} (ho : Ordinal.type r = o) (ho' : Ordinal.type r' = o) (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v})
Goal: Ordinal.sup (Ordinal.familyOfBFamily' r ho f) ≤ Ordinal.sup (Ordinal.familyOfBFamily' r' ho' f)
-- Ordinal.sup_eq_sup
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) 
Arguments: {ι ι' : Type u} (r : ι → ι → Prop) (r' : ι' → ι' → Prop) [IsWellOrder ι r] [IsWellOrder ι' r'] {o : Ordinal.{u}} (ho : Ordinal.type r = o) (ho' : Ordinal.type r' = o) (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v})
Goal: Ordinal.sup (Ordinal.familyOfBFamily' r ho f) = Ordinal.sup (Ordinal.familyOfBFamily' r' ho' f)
-- Ordinal.sup_eq_bsup
@[simp]
theorem sup_eq_bsup {o : Ordinal.{u}} (f : ∀ a < o, Ordinal.{max u v}) :
    sup.{_, v} (familyOfBFamily o f) = bsup.{_, v} o f 
Arguments: {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v})
Goal: Ordinal.sup (o.familyOfBFamily f) = o.bsup f
-- Ordinal.sup_eq_bsup'
@[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 
Arguments: {o : Ordinal.{u}} {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (ho : Ordinal.type r = o) (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v})
Goal: Ordinal.sup (Ordinal.familyOfBFamily' r ho f) = o.bsup f
-- Ordinal.sSup_eq_bsup
@[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 
Arguments: {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v})
Goal: sSup (o.brange f) = o.bsup f
-- Ordinal.bsup_eq_sup'
@[simp]
theorem bsup_eq_sup' {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → Ordinal.{max u v}) :
    bsup.{_, v} _ (bfamilyOfFamily' r f) = sup.{_, v} f 
Arguments: {ι : Type u} (r : ι → ι → Prop) [IsWellOrder ι r] (f : ι → Ordinal.{max u v})
Goal: (Ordinal.type r).bsup (Ordinal.bfamilyOfFamily' r f) = Ordinal.sup f
-- Ordinal.bsup_eq_bsup
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) 
Arguments: {ι : Type u} (r r' : ι → ι → Prop) [IsWellOrder ι r] [IsWellOrder ι r'] (f : ι → Ordinal.{max u v})
Goal: (Ordinal.type r).bsup (Ordinal.bfamilyOfFamily' r f) = (Ordinal.type r').bsup (Ordinal.bfamilyOfFamily' r' f)
-- Ordinal.bsup_eq_sup
@[simp]
theorem bsup_eq_sup {ι : Type u} (f : ι → Ordinal.{max u v}) :
    bsup.{_, v} _ (bfamilyOfFamily f) = sup.{_, v} f 
Arguments: {ι : Type u} (f : ι → Ordinal.{max u v})
Goal: (Ordinal.type WellOrderingRel).bsup (Ordinal.bfamilyOfFamily f) = Ordinal.sup f
-- Ordinal.bsup_congr
@[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) 
Arguments: {o₁ o₂ : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o₁ → Ordinal.{max u v}) (ho : o₁ = o₂)
Goal: o₁.bsup f = o₂.bsup fun a h => f a ⋯
-- Ordinal.bsup_le_iff
theorem bsup_le_iff {o f a} : bsup.{u, v} o f ≤ a ↔ ∀ i h, f i h ≤ a 
Arguments: {o : Ordinal.{u}} {f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}} {a : Ordinal.{max u v}}
Goal: o.bsup f ≤ a ↔ ∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a
-- Ordinal.bsup_le
theorem bsup_le {o : Ordinal} {f : ∀ b < o, Ordinal} {a} :
    (∀ i h, f i h ≤ a) → bsup.{u, v} o f ≤ a 
Arguments: {o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v}} {a : Ordinal.{max u v}}
Goal: (∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a) → o.bsup f ≤ a
-- Ordinal.le_bsup
theorem le_bsup {o} (f : ∀ a < o, Ordinal) (i h) : f i h ≤ bsup o f 
Arguments: {o : Ordinal.{u_4}} (f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_5 u_4}) (i : Ordinal.{u_4}) (h : i < o)
Goal: f i h ≤ o.bsup f
-- Ordinal.lt_bsup
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 
Arguments: {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}) {a : Ordinal.{max u v}}
Goal: a < o.bsup f ↔ ∃ i, ∃ (hi : i < o), a < f i hi