ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fintype.exists_le_sum_fiber_of_nsmul_le_sum
theorem exists_le_sum_fiber_of_nsmul_le_sum [Nonempty β] (hb : card β • b ≤ ∑ x, w x) :
    ∃ y, b ≤ ∑ x ∈ univ.filter fun x => f x = y, w x 
Arguments: {α : Type u} {β : Type v} {M : Type w} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {w : α → M} {b : M} [LinearOrderedCancelAddCommMonoid M] [Nonempty β] (hb : Fintype.card β • b ≤ ∑ x : α, w x)
Goal: ∃ y, b ≤ ∑ x ∈ Finset.filter (fun x => f x = y) Finset.univ, w x
-- Fintype.exists_sum_fiber_lt_of_sum_lt_nsmul
theorem exists_sum_fiber_lt_of_sum_lt_nsmul (hb : ∑ x, w x < card β • b) :
    ∃ y, ∑ x ∈ univ.filter fun x => f x = y, w x < b 
Arguments: {α : Type u} {β : Type v} {M : Type w} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {w : α → M} {b : M} [LinearOrderedCancelAddCommMonoid M] (hb : ∑ x : α, w x < Fintype.card β • b)
Goal: ∃ y, ∑ x ∈ Finset.filter (fun x => f x = y) Finset.univ, w x < b
-- Fintype.exists_sum_fiber_le_of_sum_le_nsmul
theorem exists_sum_fiber_le_of_sum_le_nsmul [Nonempty β] (hb : ∑ x, w x ≤ card β • b) :
    ∃ y, ∑ x ∈ univ.filter fun x => f x = y, w x ≤ b 
Arguments: {α : Type u} {β : Type v} {M : Type w} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {w : α → M} {b : M} [LinearOrderedCancelAddCommMonoid M] [Nonempty β] (hb : ∑ x : α, w x ≤ Fintype.card β • b)
Goal: ∃ y, ∑ x ∈ Finset.filter (fun x => f x = y) Finset.univ, w x ≤ b
-- Fintype.exists_lt_card_fiber_of_nsmul_lt_card
theorem exists_lt_card_fiber_of_nsmul_lt_card (hb : card β • b < card α) :
    ∃ y : β, b < (univ.filter fun x => f x = y).card 
Arguments: {α : Type u} {β : Type v} {M : Type w} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {b : M} [LinearOrderedCommSemiring M] (hb : Fintype.card β • b < ↑(Fintype.card α))
Goal: ∃ y, b < ↑(Finset.filter (fun x => f x = y) Finset.univ).card
-- Fintype.exists_lt_card_fiber_of_mul_lt_card
theorem exists_lt_card_fiber_of_mul_lt_card (hn : card β * n < card α) :
    ∃ y : β, n < (univ.filter fun x => f x = y).card 
Arguments: {α : Type u} {β : Type v} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {n : ℕ} (hn : Fintype.card β * n < Fintype.card α)
Goal: ∃ y, n < (Finset.filter (fun x => f x = y) Finset.univ).card
-- Fintype.exists_card_fiber_lt_of_card_lt_nsmul
theorem exists_card_fiber_lt_of_card_lt_nsmul (hb : ↑(card α) < card β • b) :
    ∃ y : β, ↑(univ.filter fun x => f x = y).card < b 
Arguments: {α : Type u} {β : Type v} {M : Type w} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {b : M} [LinearOrderedCommSemiring M] (hb : ↑(Fintype.card α) < Fintype.card β • b)
Goal: ∃ y, ↑(Finset.filter (fun x => f x = y) Finset.univ).card < b
-- Fintype.exists_card_fiber_lt_of_card_lt_mul
theorem exists_card_fiber_lt_of_card_lt_mul (hn : card α < card β * n) :
    ∃ y : β, (univ.filter fun x => f x = y).card < n 
Arguments: {α : Type u} {β : Type v} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {n : ℕ} (hn : Fintype.card α < Fintype.card β * n)
Goal: ∃ y, (Finset.filter (fun x => f x = y) Finset.univ).card < n
-- Fintype.exists_le_card_fiber_of_nsmul_le_card
theorem exists_le_card_fiber_of_nsmul_le_card [Nonempty β] (hb : card β • b ≤ card α) :
    ∃ y : β, b ≤ (univ.filter fun x => f x = y).card 
Arguments: {α : Type u} {β : Type v} {M : Type w} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {b : M} [LinearOrderedCommSemiring M] [Nonempty β] (hb : Fintype.card β • b ≤ ↑(Fintype.card α))
Goal: ∃ y, b ≤ ↑(Finset.filter (fun x => f x = y) Finset.univ).card
-- Fintype.exists_le_card_fiber_of_mul_le_card
theorem exists_le_card_fiber_of_mul_le_card [Nonempty β] (hn : card β * n ≤ card α) :
    ∃ y : β, n ≤ (univ.filter fun x => f x = y).card 
Arguments: {α : Type u} {β : Type v} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {n : ℕ} [Nonempty β] (hn : Fintype.card β * n ≤ Fintype.card α)
Goal: ∃ y, n ≤ (Finset.filter (fun x => f x = y) Finset.univ).card
-- Fintype.exists_card_fiber_le_of_card_le_nsmul
theorem exists_card_fiber_le_of_card_le_nsmul [Nonempty β] (hb : ↑(card α) ≤ card β • b) :
    ∃ y : β, ↑(univ.filter fun x => f x = y).card ≤ b 
Arguments: {α : Type u} {β : Type v} {M : Type w} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {b : M} [LinearOrderedCommSemiring M] [Nonempty β] (hb : ↑(Fintype.card α) ≤ Fintype.card β • b)
Goal: ∃ y, ↑(Finset.filter (fun x => f x = y) Finset.univ).card ≤ b
-- Fintype.exists_card_fiber_le_of_card_le_mul
theorem exists_card_fiber_le_of_card_le_mul [Nonempty β] (hn : card α ≤ card β * n) :
    ∃ y : β, (univ.filter fun x => f x = y).card ≤ n 
Arguments: {α : Type u} {β : Type v} [DecidableEq β] [Fintype α] [Fintype β] (f : α → β) {n : ℕ} [Nonempty β] (hn : Fintype.card α ≤ Fintype.card β * n)
Goal: ∃ y, (Finset.filter (fun x => f x = y) Finset.univ).card ≤ n
-- Nat.exists_lt_modEq_of_infinite
theorem exists_lt_modEq_of_infinite {s : Set ℕ} (hs : s.Infinite) {k : ℕ} (hk : 0 < k) :
    ∃ m ∈ s, ∃ n ∈ s, m < n ∧ m ≡ n [MOD k] 
Arguments: {s : Set ℕ} (hs : s.Infinite) {k : ℕ} (hk : 0 < k)
Goal: ∃ m ∈ s, ∃ n ∈ s, m < n ∧ m ≡ n [MOD k]
-- Ordinal.lift_add
@[simp]
theorem lift_add (a b : Ordinal.{v}) : lift.{u} (a + b) = lift.{u} a + lift.{u} b 
Arguments: (a b : Ordinal.{v})
Goal: Ordinal.lift.{u, v} (a + b) = Ordinal.lift.{u, v} a + Ordinal.lift.{u, v} b
-- Ordinal.lift_succ
@[simp]
theorem lift_succ (a : Ordinal.{v}) : lift.{u} (succ a) = succ (lift.{u} a) 
Arguments: (a : Ordinal.{v})
Goal: Ordinal.lift.{u, v} (Order.succ a) = Order.succ (Ordinal.lift.{u, v} a)
-- Ordinal.add_left_cancel
theorem add_left_cancel (a) {b c : Ordinal} : a + b = a + c ↔ b = c 
Arguments: (a : Ordinal.{u_4}) {b c : Ordinal.{u_4}}
Goal: a + b = a + c ↔ b = c
-- _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.add_lt_add_iff_left'
private theorem add_lt_add_iff_left' (a) {b c : Ordinal} : a + b < a + c ↔ b < c 
Arguments: (a : Ordinal.{u_4}) {b c : Ordinal.{u_4}}
Goal: a + b < a + c ↔ b < c
-- Ordinal.add_le_add_iff_right
theorem add_le_add_iff_right {a b : Ordinal} : ∀ n : ℕ, a + n ≤ b + n ↔ a ≤ b
  
Arguments: {a b : Ordinal.{u_4}} (n : ℕ)
Goal: a + ↑n ≤ b + ↑n ↔ a ≤ b
-- Ordinal.add_right_cancel
theorem add_right_cancel {a b : Ordinal} (n : ℕ) : a + n = b + n ↔ a = b 
Arguments: {a b : Ordinal.{u_4}} (n : ℕ)
Goal: a + ↑n = b + ↑n ↔ a = b
-- Ordinal.add_eq_zero_iff
theorem add_eq_zero_iff {a b : Ordinal} : a + b = 0 ↔ a = 0 ∧ b = 0 
Arguments: {a b : Ordinal.{u_4}}
Goal: a + b = 0 ↔ a = 0 ∧ b = 0
-- Ordinal.left_eq_zero_of_add_eq_zero
theorem left_eq_zero_of_add_eq_zero {a b : Ordinal} (h : a + b = 0) : a = 0 
Arguments: {a b : Ordinal.{u_4}} (h : a + b = 0)
Goal: a = 0
-- Ordinal.right_eq_zero_of_add_eq_zero
theorem right_eq_zero_of_add_eq_zero {a b : Ordinal} (h : a + b = 0) : b = 0 
Arguments: {a b : Ordinal.{u_4}} (h : a + b = 0)
Goal: b = 0
-- Ordinal.pred_succ
@[simp]
theorem pred_succ (o) : pred (succ o) = o 
Arguments: (o : Ordinal.{u_4})
Goal: (Order.succ o).pred = o
-- Ordinal.pred_le_self
theorem pred_le_self (o) : pred o ≤ o 
Arguments: (o : Ordinal.{u_4})
Goal: o.pred ≤ o
-- Ordinal.pred_eq_iff_not_succ
theorem pred_eq_iff_not_succ {o} : pred o = o ↔ ¬∃ a, o = succ a 
Arguments: {o : Ordinal.{u_4}}
Goal: o.pred = o ↔ ¬∃ a, o = Order.succ a
-- Ordinal.pred_eq_iff_not_succ'
theorem pred_eq_iff_not_succ' {o} : pred o = o ↔ ∀ a, o ≠ succ a 
Arguments: {o : Ordinal.{u_4}}
Goal: o.pred = o ↔ ∀ (a : Ordinal.{u_4}), o ≠ Order.succ a
-- Ordinal.pred_lt_iff_is_succ
theorem pred_lt_iff_is_succ {o} : pred o < o ↔ ∃ a, o = succ a 
Arguments: {o : Ordinal.{u_4}}
Goal: o.pred < o ↔ ∃ a, o = Order.succ a
-- Ordinal.pred_zero
@[simp]
theorem pred_zero : pred 0 = 0 
Goal: Ordinal.pred 0 = 0
-- Ordinal.succ_pred_iff_is_succ
theorem succ_pred_iff_is_succ {o} : succ (pred o) = o ↔ ∃ a, o = succ a 
Arguments: {o : Ordinal.{u_4}}
Goal: Order.succ o.pred = o ↔ ∃ a, o = Order.succ a
-- Ordinal.succ_lt_of_not_succ
theorem succ_lt_of_not_succ {o b : Ordinal} (h : ¬∃ a, o = succ a) : succ b < o ↔ b < o 
Arguments: {o b : Ordinal.{u_4}} (h : ¬∃ a, o = Order.succ a)
Goal: Order.succ b < o ↔ b < o
-- Ordinal.lt_pred
theorem lt_pred {a b} : a < pred b ↔ succ a < b 
Arguments: {a b : Ordinal.{u_4}}
Goal: a < b.pred ↔ Order.succ a < b
-- Ordinal.pred_le
theorem pred_le {a b} : pred a ≤ b ↔ a ≤ succ b 
Arguments: {a b : Ordinal.{u_4}}
Goal: a.pred ≤ b ↔ a ≤ Order.succ b
-- Ordinal.lift_is_succ
@[simp]
theorem lift_is_succ {o : Ordinal.{v}} : (∃ a, lift.{u} o = succ a) ↔ ∃ a, o = succ a 
Arguments: {o : Ordinal.{v}}
Goal: (∃ a, Ordinal.lift.{u, v} o = Order.succ a) ↔ ∃ a, o = Order.succ a
-- Ordinal.lift_pred
@[simp]
theorem lift_pred (o : Ordinal.{v}) : lift.{u} (pred o) = pred (lift.{u} o) 
Arguments: (o : Ordinal.{v})
Goal: Ordinal.lift.{u, v} o.pred = (Ordinal.lift.{u, v} o).pred
-- Ordinal.IsLimit.isSuccLimit
theorem IsLimit.isSuccLimit {o} (h : IsLimit o) : IsSuccLimit o 
Arguments: {o : Ordinal.{u_4}} (h : o.IsLimit)
Goal: Order.IsSuccLimit o
-- Ordinal.IsLimit.succ_lt
theorem IsLimit.succ_lt {o a : Ordinal} (h : IsLimit o) : a < o → succ a < o 
Arguments: {o a : Ordinal.{u_4}} (h : o.IsLimit)
Goal: a < o → Order.succ a < o
-- Ordinal.isSuccLimit_zero
theorem isSuccLimit_zero : IsSuccLimit (0 : Ordinal) 
Goal: Order.IsSuccLimit 0
-- Ordinal.not_zero_isLimit
theorem not_zero_isLimit : ¬IsLimit 0
  
Goal: ¬Ordinal.IsLimit 0
-- Ordinal.not_succ_isLimit
theorem not_succ_isLimit (o) : ¬IsLimit (succ o)
  
Arguments: (o : Ordinal.{u_4})
Goal: ¬(Order.succ o).IsLimit
-- Ordinal.not_succ_of_isLimit
theorem not_succ_of_isLimit {o} (h : IsLimit o) : ¬∃ a, o = succ a
  
Arguments: {o : Ordinal.{u_4}} (h : o.IsLimit)
Goal: ¬∃ a, o = Order.succ a
-- Ordinal.succ_lt_of_isLimit
theorem succ_lt_of_isLimit {o a : Ordinal} (h : IsLimit o) : succ a < o ↔ a < o 
Arguments: {o a : Ordinal.{u_4}} (h : o.IsLimit)
Goal: Order.succ a < o ↔ a < o
-- Ordinal.le_succ_of_isLimit
theorem le_succ_of_isLimit {o} (h : IsLimit o) {a} : o ≤ succ a ↔ o ≤ a 
Arguments: {o : Ordinal.{u_4}} (h : o.IsLimit) {a : Ordinal.{u_4}}
Goal: o ≤ Order.succ a ↔ o ≤ a
-- Ordinal.limit_le
theorem limit_le {o} (h : IsLimit o) {a} : o ≤ a ↔ ∀ x < o, x ≤ a 
Arguments: {o : Ordinal.{u_4}} (h : o.IsLimit) {a : Ordinal.{u_4}}
Goal: o ≤ a ↔ ∀ x < o, x ≤ a
-- Ordinal.lt_limit
theorem lt_limit {o} (h : IsLimit o) {a} : a < o ↔ ∃ x < o, a < x 
Arguments: {o : Ordinal.{u_4}} (h : o.IsLimit) {a : Ordinal.{u_4}}
Goal: a < o ↔ ∃ x < o, a < x
-- Ordinal.lift_isLimit
@[simp]
theorem lift_isLimit (o : Ordinal.{v}) : IsLimit (lift.{u,v} o) ↔ IsLimit o 
Arguments: (o : Ordinal.{v})
Goal: (Ordinal.lift.{u, v} o).IsLimit ↔ o.IsLimit
-- Ordinal.IsLimit.pos
theorem IsLimit.pos {o : Ordinal} (h : IsLimit o) : 0 < o 
Arguments: {o : Ordinal.{u_4}} (h : o.IsLimit)
Goal: 0 < o
-- Ordinal.IsLimit.one_lt
theorem IsLimit.one_lt {o : Ordinal} (h : IsLimit o) : 1 < o 
Arguments: {o : Ordinal.{u_4}} (h : o.IsLimit)
Goal: 1 < o
-- Ordinal.IsLimit.nat_lt
theorem IsLimit.nat_lt {o : Ordinal} (h : IsLimit o) : ∀ n : ℕ, (n : Ordinal) < o
  
Arguments: {o : Ordinal.{u_4}} (h : o.IsLimit) (n : ℕ)
Goal: ↑n < o
-- Ordinal.zero_or_succ_or_limit
theorem zero_or_succ_or_limit (o : Ordinal) : o = 0 ∨ (∃ a, o = succ a) ∨ IsLimit o 
Arguments: (o : Ordinal.{u_4})
Goal: o = 0 ∨ (∃ a, o = Order.succ a) ∨ o.IsLimit
-- Ordinal.limitRecOn_zero
@[simp]
theorem limitRecOn_zero {C} (H₁ H₂ H₃) : @limitRecOn C 0 H₁ H₂ H₃ = H₁ 
Arguments: {C : Ordinal.{u_4} → Sort u_5} (H₁ : C 0) (H₂ : (o : Ordinal.{u_4}) → C o → C (Order.succ o)) (H₃ : (o : Ordinal.{u_4}) → o.IsLimit → ((o' : Ordinal.{u_4}) → o' < o → C o') → C o)
Goal: Ordinal.limitRecOn 0 H₁ H₂ H₃ = H₁
-- Ordinal.limitRecOn_succ
@[simp]
theorem limitRecOn_succ {C} (o H₁ H₂ H₃) :
    @limitRecOn C (succ o) H₁ H₂ H₃ = H₂ o (@limitRecOn C o H₁ H₂ H₃) 
Arguments: {C : Ordinal.{u_4} → Sort u_5} (o : Ordinal.{u_4}) (H₁ : C 0) (H₂ : (o : Ordinal.{u_4}) → C o → C (Order.succ o)) (H₃ : (o : Ordinal.{u_4}) → o.IsLimit → ((o' : Ordinal.{u_4}) → o' < o → C o') → C o)
Goal: (Order.succ o).limitRecOn H₁ H₂ H₃ = H₂ o (o.limitRecOn H₁ H₂ H₃)
-- Ordinal.limitRecOn_limit
@[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₃ 
Arguments: {C : Ordinal.{u_4} → Sort u_5} (o : Ordinal.{u_4}) (H₁ : C 0) (H₂ : (o : Ordinal.{u_4}) → C o → C (Order.succ o)) (H₃ : (o : Ordinal.{u_4}) → o.IsLimit → ((o' : Ordinal.{u_4}) → o' < o → C o') → C o) (h : o.IsLimit)
Goal: o.limitRecOn H₁ H₂ H₃ = H₃ o h fun x _h => x.limitRecOn H₁ H₂ H₃
-- Ordinal.enum_succ_eq_top
theorem enum_succ_eq_top {o : Ordinal} :
    enum (· < ·) o
        (by
          rw [type_lt]
          exact lt_succ o) =
      (⊤ : (succ o).out.α) 
Arguments: {o : Ordinal.{u_4}}
Goal: Ordinal.enum (fun x x_1 => x < x_1) o ⋯ = ⊤
-- Ordinal.has_succ_of_type_succ_lt
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 
Arguments: {α : Type u_4} {r : α → α → Prop} [wo : IsWellOrder α r] (h : ∀ a < Ordinal.type r, Order.succ a < Ordinal.type r) (x : α)
Goal: ∃ y, r x y
-- Ordinal.out_no_max_of_succ_lt
theorem out_no_max_of_succ_lt {o : Ordinal} (ho : ∀ a < o, succ a < o) : NoMaxOrder o.out.α 
Arguments: {o : Ordinal.{u_4}} (ho : ∀ a < o, Order.succ a < o)
Goal: NoMaxOrder (Quotient.out o).α
-- Ordinal.bounded_singleton
theorem bounded_singleton {r : α → α → Prop} [IsWellOrder α r] (hr : (type r).IsLimit) (x) :
    Bounded r {x} 
Arguments: {α : Type u_1} {r : α → α → Prop} [IsWellOrder α r] (hr : (Ordinal.type r).IsLimit) (x : α)
Goal: Set.Bounded r {x}
-- Ordinal.type_subrel_lt
theorem type_subrel_lt (o : Ordinal.{u}) :
    type (Subrel ((· < ·) : Ordinal → Ordinal → Prop) { o' : Ordinal | o' < o })
      = Ordinal.lift.{u + 1} o 
Arguments: (o : Ordinal.{u})
Goal: Ordinal.type (Subrel (fun x x_1 => x < x_1) {o' | o' < o}) = Ordinal.lift.{u + 1, u} o
-- Ordinal.mk_initialSeg
theorem mk_initialSeg (o : Ordinal.{u}) :
    #{ o' : Ordinal | o' < o } = Cardinal.lift.{u + 1} o.card 
Arguments: (o : Ordinal.{u})
Goal: #↑{o' | o' < o} = Cardinal.lift.{u + 1, u} o.card
-- Ordinal.IsNormal.limit_le
theorem IsNormal.limit_le {f} (H : IsNormal f) :
    ∀ {o}, IsLimit o → ∀ {a}, f o ≤ a ↔ ∀ b < o, f b ≤ a 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} (H : Ordinal.IsNormal f) {o : Ordinal.{u_4}}
Goal: o.IsLimit → ∀ {a : Ordinal.{u_5}}, f o ≤ a ↔ ∀ b < o, f b ≤ a
-- Ordinal.IsNormal.limit_lt
theorem IsNormal.limit_lt {f} (H : IsNormal f) {o} (h : IsLimit o) {a} :
    a < f o ↔ ∃ b < o, a < f b 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} (H : Ordinal.IsNormal f) {o : Ordinal.{u_4}} (h : o.IsLimit) {a : Ordinal.{u_5}}
Goal: a < f o ↔ ∃ b < o, a < f b
-- Ordinal.IsNormal.strictMono
theorem IsNormal.strictMono {f} (H : IsNormal f) : StrictMono f 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} (H : Ordinal.IsNormal f)
Goal: StrictMono f
-- Ordinal.IsNormal.monotone
theorem IsNormal.monotone {f} (H : IsNormal f) : Monotone f 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} (H : Ordinal.IsNormal f)
Goal: Monotone f
-- Ordinal.isNormal_iff_strictMono_limit
theorem isNormal_iff_strictMono_limit (f : Ordinal → Ordinal) :
    IsNormal f ↔ StrictMono f ∧ ∀ o, IsLimit o → ∀ a, (∀ b < o, f b ≤ a) → f o ≤ a 
Arguments: (f : Ordinal.{u_4} → Ordinal.{u_5})
Goal: Ordinal.IsNormal f ↔
  StrictMono f ∧ ∀ (o : Ordinal.{u_4}), o.IsLimit → ∀ (a : Ordinal.{u_5}), (∀ b < o, f b ≤ a) → f o ≤ a
-- Ordinal.IsNormal.lt_iff
theorem IsNormal.lt_iff {f} (H : IsNormal f) {a b} : f a < f b ↔ a < b 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} (H : Ordinal.IsNormal f) {a b : Ordinal.{u_4}}
Goal: f a < f b ↔ a < b
-- Ordinal.IsNormal.le_iff
theorem IsNormal.le_iff {f} (H : IsNormal f) {a b} : f a ≤ f b ↔ a ≤ b 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} (H : Ordinal.IsNormal f) {a b : Ordinal.{u_4}}
Goal: f a ≤ f b ↔ a ≤ b
-- Ordinal.IsNormal.inj
theorem IsNormal.inj {f} (H : IsNormal f) {a b} : f a = f b ↔ a = b 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} (H : Ordinal.IsNormal f) {a b : Ordinal.{u_4}}
Goal: f a = f b ↔ a = b
-- Ordinal.IsNormal.self_le
theorem IsNormal.self_le {f} (H : IsNormal f) (a) : a ≤ f a 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_4}} (H : Ordinal.IsNormal f) (a : Ordinal.{u_4})
Goal: a ≤ f a
-- Ordinal.IsNormal.le_set
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 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} {o : Ordinal.{u_5}} (H : Ordinal.IsNormal f) (p : Set Ordinal.{u_4}) (p0 : p.Nonempty) (b : Ordinal.{u_4}) (H₂ : ∀ (o : Ordinal.{u_4}), b ≤ o ↔ ∀ a ∈ p, a ≤ o)
Goal: f b ≤ o ↔ ∀ a ∈ p, f a ≤ o
-- Ordinal.IsNormal.le_set'
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 
Arguments: {α : Type u_1} {f : Ordinal.{u_4} → Ordinal.{u_5}} {o : Ordinal.{u_5}} (H : Ordinal.IsNormal f) (p : Set α) (p0 : p.Nonempty) (g : α → Ordinal.{u_4}) (b : Ordinal.{u_4}) (H₂ : ∀ (o : Ordinal.{u_4}), b ≤ o ↔ ∀ a ∈ p, g a ≤ o)
Goal: f b ≤ o ↔ ∀ a ∈ p, f (g a) ≤ o
-- Ordinal.IsNormal.refl
theorem IsNormal.refl : IsNormal id 
Goal: Ordinal.IsNormal id
-- Ordinal.IsNormal.trans
theorem IsNormal.trans {f g} (H₁ : IsNormal f) (H₂ : IsNormal g) : IsNormal (f ∘ g) 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} {g : Ordinal.{u_6} → Ordinal.{u_4}} (H₁ : Ordinal.IsNormal f) (H₂ : Ordinal.IsNormal g)
Goal: Ordinal.IsNormal (f ∘ g)
-- Ordinal.IsNormal.isLimit
theorem IsNormal.isLimit {f} (H : IsNormal f) {o} (l : IsLimit o) : IsLimit (f o) 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_5}} (H : Ordinal.IsNormal f) {o : Ordinal.{u_4}} (l : o.IsLimit)
Goal: (f o).IsLimit
-- Ordinal.IsNormal.le_iff_eq
theorem IsNormal.le_iff_eq {f} (H : IsNormal f) {a} : f a ≤ a ↔ f a = a 
Arguments: {f : Ordinal.{u_4} → Ordinal.{u_4}} (H : Ordinal.IsNormal f) {a : Ordinal.{u_4}}
Goal: f a ≤ a ↔ f a = a
-- Ordinal.add_le_of_limit
theorem add_le_of_limit {a b c : Ordinal} (h : IsLimit b) : a + b ≤ c ↔ ∀ b' < b, a + b' ≤ c 
Arguments: {a b c : Ordinal.{u_4}} (h : b.IsLimit)
Goal: a + b ≤ c ↔ ∀ b' < b, a + b' ≤ c
-- Ordinal.add_isNormal
theorem add_isNormal (a : Ordinal) : IsNormal (a + ·) 
Arguments: (a : Ordinal.{u_4})
Goal: Ordinal.IsNormal fun x => a + x
-- Ordinal.add_isLimit
theorem add_isLimit (a) {b} : IsLimit b → IsLimit (a + b) 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}}
Goal: b.IsLimit → (a + b).IsLimit
-- Ordinal.sub_nonempty
theorem sub_nonempty {a b : Ordinal} : { o | a ≤ b + o }.Nonempty 
Arguments: {a b : Ordinal.{u_4}}
Goal: {o | a ≤ b + o}.Nonempty
-- Ordinal.le_add_sub
theorem le_add_sub (a b : Ordinal) : a ≤ b + (a - b) 
Arguments: (a b : Ordinal.{u_4})
Goal: a ≤ b + (a - b)
-- Ordinal.sub_le
theorem sub_le {a b c : Ordinal} : a - b ≤ c ↔ a ≤ b + c 
Arguments: {a b c : Ordinal.{u_4}}
Goal: a - b ≤ c ↔ a ≤ b + c
-- Ordinal.lt_sub
theorem lt_sub {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.add_sub_cancel
theorem add_sub_cancel (a b : Ordinal) : a + b - a = b 
Arguments: (a b : Ordinal.{u_4})
Goal: a + b - a = b
-- Ordinal.sub_eq_of_add_eq
theorem sub_eq_of_add_eq {a b c : Ordinal} (h : a + b = c) : c - a = b 
Arguments: {a b c : Ordinal.{u_4}} (h : a + b = c)
Goal: c - a = b
-- Ordinal.sub_le_self
theorem sub_le_self (a b : Ordinal) : a - b ≤ a 
Arguments: (a b : Ordinal.{u_4})
Goal: a - b ≤ a
-- Ordinal.add_sub_cancel_of_le
protected theorem add_sub_cancel_of_le {a b : Ordinal} (h : b ≤ a) : b + (a - b) = a 
Arguments: {a b : Ordinal.{u_4}} (h : b ≤ a)
Goal: b + (a - b) = a
-- Ordinal.le_sub_of_le
theorem le_sub_of_le {a b c : Ordinal} (h : b ≤ a) : c ≤ a - b ↔ b + c ≤ a 
Arguments: {a b c : Ordinal.{u_4}} (h : b ≤ a)
Goal: c ≤ a - b ↔ b + c ≤ a
-- Ordinal.sub_lt_of_le
theorem sub_lt_of_le {a b c : Ordinal} (h : b ≤ a) : a - b < c ↔ a < b + c 
Arguments: {a b c : Ordinal.{u_4}} (h : b ≤ a)
Goal: a - b < c ↔ a < b + c
-- Ordinal.sub_zero
@[simp]
theorem sub_zero (a : Ordinal) : a - 0 = a 
Arguments: (a : Ordinal.{u_4})
Goal: a - 0 = a
-- Ordinal.zero_sub
@[simp]
theorem zero_sub (a : Ordinal) : 0 - a = 0 
Arguments: (a : Ordinal.{u_4})
Goal: 0 - a = 0
-- Ordinal.sub_self
@[simp]
theorem sub_self (a : Ordinal) : a - a = 0 
Arguments: (a : Ordinal.{u_4})
Goal: a - a = 0
-- Ordinal.sub_eq_zero_iff_le
protected theorem sub_eq_zero_iff_le {a b : Ordinal} : a - b = 0 ↔ a ≤ b 
Arguments: {a b : Ordinal.{u_4}}
Goal: a - b = 0 ↔ a ≤ b
-- Ordinal.sub_sub
theorem sub_sub (a b c : Ordinal) : a - b - c = a - (b + c) 
Arguments: (a b c : Ordinal.{u_4})
Goal: a - b - c = a - (b + c)
-- Ordinal.add_sub_add_cancel
@[simp]
theorem add_sub_add_cancel (a b c : Ordinal) : a + b - (a + c) = b - c 
Arguments: (a b c : Ordinal.{u_4})
Goal: a + b - (a + c) = b - c
-- Ordinal.sub_isLimit
theorem sub_isLimit {a b} (l : IsLimit a) (h : b < a) : IsLimit (a - b) 
Arguments: {a b : Ordinal.{u_4}} (l : a.IsLimit) (h : b < a)
Goal: (a - b).IsLimit
-- Ordinal.one_add_omega
theorem one_add_omega : 1 + ω = ω 
Goal: 1 + ω = ω
-- Ordinal.one_add_of_omega_le
@[simp]
theorem one_add_of_omega_le {o} (h : ω ≤ o) : 1 + o = o 
Arguments: {o : Ordinal.{u_4}} (h : ω ≤ o)
Goal: 1 + o = o
-- Ordinal.type_prod_lex
@[simp]
theorem type_prod_lex {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [IsWellOrder α r]
    [IsWellOrder β s] : type (Prod.Lex s r) = type r * type s 
Arguments: {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.type (Prod.Lex s r) = Ordinal.type r * Ordinal.type s
-- _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.mul_eq_zero'
private theorem mul_eq_zero' {a b : Ordinal} : a * b = 0 ↔ a = 0 ∨ b = 0 
Arguments: {a b : Ordinal.{u_4}}
Goal: a * b = 0 ↔ a = 0 ∨ b = 0
-- Ordinal.lift_mul
@[simp]
theorem lift_mul (a b : Ordinal.{v}) : lift.{u} (a * b) = lift.{u} a * lift.{u} b 
Arguments: (a b : Ordinal.{v})
Goal: Ordinal.lift.{u, v} (a * b) = Ordinal.lift.{u, v} a * Ordinal.lift.{u, v} b
-- Ordinal.card_mul
@[simp]
theorem card_mul (a b) : card (a * b) = card a * card b 
Arguments: (a b : Ordinal.{u_4})
Goal: (a * b).card = a.card * b.card
-- Ordinal.mul_succ
theorem mul_succ (a b : Ordinal) : a * succ b = a * b + a 
Arguments: (a b : Ordinal.{u_4})
Goal: a * Order.succ b = a * b + a
-- Ordinal.le_mul_left
theorem le_mul_left (a : Ordinal) {b : Ordinal} (hb : 0 < b) : a ≤ a * b 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}} (hb : 0 < b)
Goal: a ≤ a * b
-- Ordinal.le_mul_right
theorem le_mul_right (a : Ordinal) {b : Ordinal} (hb : 0 < b) : a ≤ b * a 
Arguments: (a : Ordinal.{u_4}) {b : Ordinal.{u_4}} (hb : 0 < b)
Goal: a ≤ b * a
-- _private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.mul_le_of_limit_aux
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 
Arguments: {α β : Type u_4} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] {c : Ordinal.{u_4}} (h : (Ordinal.type s).IsLimit) (H : ∀ b' < Ordinal.type s, Ordinal.type r * b' ≤ c) (l : c < Ordinal.type r * Ordinal.type s)
Goal: False
-- Ordinal.mul_le_of_limit
theorem mul_le_of_limit {a b c : Ordinal} (h : IsLimit b) : a * b ≤ c ↔ ∀ b' < b, a * b' ≤ c 
Arguments: {a b c : Ordinal.{u_4}} (h : b.IsLimit)
Goal: a * b ≤ c ↔ ∀ b' < b, a * b' ≤ c
-- Ordinal.mul_isNormal
theorem mul_isNormal {a : Ordinal} (h : 0 < a) : IsNormal (a * ·) 
Arguments: {a : Ordinal.{u_4}} (h : 0 < a)
Goal: Ordinal.IsNormal fun x => a * x
-- Ordinal.lt_mul_of_limit
theorem lt_mul_of_limit {a b c : Ordinal} (h : IsLimit c) : a < b * c ↔ ∃ c' < c, a < b * c' 
Arguments: {a b c : Ordinal.{u_4}} (h : c.IsLimit)
Goal: a < b * c ↔ ∃ c' < c, a < b * c'
-- Ordinal.mul_lt_mul_iff_left
theorem mul_lt_mul_iff_left {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_le_mul_iff_left
theorem mul_le_mul_iff_left {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_lt_mul_of_pos_left
theorem mul_lt_mul_of_pos_left {a b c : Ordinal} (h : a < b) (c0 : 0 < c) : c * a < c * b 
Arguments: {a b c : Ordinal.{u_4}} (h : a < b) (c0 : 0 < c)
Goal: c * a < c * b