ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ordinal.inductionOn
@[elab_as_elim]
theorem inductionOn {C : Ordinal → Prop} (o : Ordinal)
    (H : ∀ (α r) [IsWellOrder α r], C (type r)) : C o 
Arguments: {C : Ordinal.{u_3} → Prop} (o : Ordinal.{u_3}) (H : ∀ (α : Type u_3) (r : α → α → Prop) [inst : IsWellOrder α r], C (Ordinal.type r))
Goal: C o
-- Ordinal.type_le_iff
theorem type_le_iff {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] : type r ≤ type s ↔ Nonempty (r ≼i s) 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.type r ≤ Ordinal.type s ↔ Nonempty (r ≼i s)
-- Ordinal.type_le_iff'
theorem type_le_iff' {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] : type r ≤ type s ↔ Nonempty (r ↪r s) 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.type r ≤ Ordinal.type s ↔ Nonempty (r ↪r s)
-- InitialSeg.ordinal_type_le
theorem _root_.InitialSeg.ordinal_type_le {α β} {r : α → α → Prop} {s : β → β → Prop}
    [IsWellOrder α r] [IsWellOrder β s] (h : r ≼i s) : type r ≤ type s 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (h : r ≼i s)
Goal: Ordinal.type r ≤ Ordinal.type s
-- RelEmbedding.ordinal_type_le
theorem _root_.RelEmbedding.ordinal_type_le {α β} {r : α → α → Prop} {s : β → β → Prop}
    [IsWellOrder α r] [IsWellOrder β s] (h : r ↪r s) : type r ≤ type s 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (h : r ↪r s)
Goal: Ordinal.type r ≤ Ordinal.type s
-- Ordinal.type_lt_iff
@[simp]
theorem type_lt_iff {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] : type r < type s ↔ Nonempty (r ≺i s) 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.type r < Ordinal.type s ↔ Nonempty (r ≺i s)
-- PrincipalSeg.ordinal_type_lt
theorem _root_.PrincipalSeg.ordinal_type_lt {α β} {r : α → α → Prop} {s : β → β → Prop}
    [IsWellOrder α r] [IsWellOrder β s] (h : r ≺i s) : type r < type s 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (h : r ≺i s)
Goal: Ordinal.type r < Ordinal.type s
-- Ordinal.zero_le
@[simp]
protected theorem zero_le (o : Ordinal) : 0 ≤ o 
Arguments: (o : Ordinal.{u_3})
Goal: 0 ≤ o
-- Ordinal.bot_eq_zero
@[simp]
theorem bot_eq_zero : (⊥ : Ordinal) = 0 
Goal: ⊥ = 0
-- Ordinal.le_zero
@[simp]
protected theorem le_zero {o : Ordinal} : o ≤ 0 ↔ o = 0 
Arguments: {o : Ordinal.{u_3}}
Goal: o ≤ 0 ↔ o = 0
-- Ordinal.pos_iff_ne_zero
protected theorem pos_iff_ne_zero {o : Ordinal} : 0 < o ↔ o ≠ 0 
Arguments: {o : Ordinal.{u_3}}
Goal: 0 < o ↔ o ≠ 0
-- Ordinal.not_lt_zero
protected theorem not_lt_zero (o : Ordinal) : ¬o < 0 
Arguments: (o : Ordinal.{u_3})
Goal: ¬o < 0
-- Ordinal.eq_zero_or_pos
theorem eq_zero_or_pos : ∀ a : Ordinal, a = 0 ∨ 0 < a 
Arguments: (a : Ordinal.{u_3})
Goal: a = 0 ∨ 0 < a
-- Ordinal.typein_lt_type
theorem typein_lt_type (r : α → α → Prop) [IsWellOrder α r] (a : α) : typein r a < type r 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] (a : α)
Goal: Ordinal.typein r a < Ordinal.type r
-- Ordinal.typein_lt_self
theorem typein_lt_self {o : Ordinal} (i : o.out.α) :
    @typein _ (· < ·) (isWellOrder_out_lt _) i < o 
Arguments: {o : Ordinal.{u_3}} (i : (Quotient.out o).α)
Goal: Ordinal.typein (fun x x_1 => x < x_1) i < o
-- Ordinal.typein_top
@[simp]
theorem typein_top {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
    (f : r ≺i s) : typein s f.top = type r 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (f : r ≺i s)
Goal: Ordinal.typein s f.top = Ordinal.type r
-- Ordinal.typein_apply
@[simp]
theorem typein_apply {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
    (f : r ≼i s) (a : α) : Ordinal.typein s (f a) = Ordinal.typein r a 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (f : r ≼i s) (a : α)
Goal: Ordinal.typein s (f a) = Ordinal.typein r a
-- Ordinal.typein_lt_typein
@[simp]
theorem typein_lt_typein (r : α → α → Prop) [IsWellOrder α r] {a b : α} :
    typein r a < typein r b ↔ r a b 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] {a b : α}
Goal: Ordinal.typein r a < Ordinal.typein r b ↔ r a b
-- Ordinal.typein_surj
theorem typein_surj (r : α → α → Prop) [IsWellOrder α r] {o} (h : o < type r) :
    ∃ a, typein r a = o 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] {o : Ordinal.{u}} (h : o < Ordinal.type r)
Goal: ∃ a, Ordinal.typein r a = o
-- Ordinal.typein_injective
theorem typein_injective (r : α → α → Prop) [IsWellOrder α r] : Injective (typein r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r]
Goal: Function.Injective (Ordinal.typein r)
-- Ordinal.typein_inj
@[simp]
theorem typein_inj (r : α → α → Prop) [IsWellOrder α r] {a b} : typein r a = typein r b ↔ a = b 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] {a b : α}
Goal: Ordinal.typein r a = Ordinal.typein r b ↔ a = b
-- Ordinal.typein.principalSeg_coe
@[simp]
theorem typein.principalSeg_coe (r : α → α → Prop) [IsWellOrder α r] :
    (typein.principalSeg r : α → Ordinal) = typein r 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r]
Goal: ⇑(Ordinal.typein.principalSeg r).toRelEmbedding = Ordinal.typein r
-- Ordinal.typein_enum
@[simp]
theorem typein_enum (r : α → α → Prop) [IsWellOrder α r] {o} (h : o < type r) :
    typein r (enum r o h) = o 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] {o : Ordinal.{u}} (h : o < Ordinal.type r)
Goal: Ordinal.typein r (Ordinal.enum r o h) = o
-- Ordinal.enum_type
theorem enum_type {α β} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
    (f : s ≺i r) {h : type s < type r} : enum r (type s) h = f.top 
Arguments: {α β : Type u_3} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (f : s ≺i r) {h : Ordinal.type s < Ordinal.type r}
Goal: Ordinal.enum r (Ordinal.type s) h = f.top
-- Ordinal.enum_typein
@[simp]
theorem enum_typein (r : α → α → Prop) [IsWellOrder α r] (a : α) :
    enum r (typein r a) (typein_lt_type r a) = a 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] (a : α)
Goal: Ordinal.enum r (Ordinal.typein r a) ⋯ = a
-- Ordinal.enum_lt_enum
theorem enum_lt_enum {r : α → α → Prop} [IsWellOrder α r] {o₁ o₂ : Ordinal} (h₁ : o₁ < type r)
    (h₂ : o₂ < type r) : r (enum r o₁ h₁) (enum r o₂ h₂) ↔ o₁ < o₂ 
Arguments: {α : Type u} {r : α → α → Prop} [IsWellOrder α r] {o₁ o₂ : Ordinal.{u}} (h₁ : o₁ < Ordinal.type r) (h₂ : o₂ < Ordinal.type r)
Goal: r (Ordinal.enum r o₁ h₁) (Ordinal.enum r o₂ h₂) ↔ o₁ < o₂
-- Ordinal.relIso_enum'
theorem relIso_enum' {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] (f : r ≃r s) (o : Ordinal) :
    ∀ (hr : o < type r) (hs : o < type s), f (enum r o hr) = enum s o hs 
Arguments: {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (f : r ≃r s) (o : Ordinal.{u}) (hr : o < Ordinal.type r) (hs : o < Ordinal.type s)
Goal: f (Ordinal.enum r o hr) = Ordinal.enum s o hs
-- Ordinal.relIso_enum
theorem relIso_enum {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r]
    [IsWellOrder β s] (f : r ≃r s) (o : Ordinal) (hr : o < type r) :
    f (enum r o hr) =
      enum s o
        (by
          convert hr using 1
          apply Quotient.sound
          exact ⟨f.symm⟩) 
Arguments: {α β : Type u} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (f : r ≃r s) (o : Ordinal.{u}) (hr : o < Ordinal.type r)
Goal: f (Ordinal.enum r o hr) = Ordinal.enum s o ⋯
-- Ordinal.lt_wf
theorem lt_wf : @WellFounded Ordinal (· < ·) 
Goal: WellFounded fun x x_1 => x < x_1
-- Ordinal.induction
theorem induction {p : Ordinal.{u} → Prop} (i : Ordinal.{u}) (h : ∀ j, (∀ k, k < j → p k) → p j) :
    p i 
Arguments: {p : Ordinal.{u} → Prop} (i : Ordinal.{u}) (h : ∀ (j : Ordinal.{u}), (∀ k < j, p k) → p j)
Goal: p i
-- Ordinal.card_type
@[simp]
theorem card_type (r : α → α → Prop) [IsWellOrder α r] : card (type r) = #α 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r]
Goal: (Ordinal.type r).card = #α
-- Ordinal.card_typein
@[simp, nolint simpNF]
theorem card_typein {r : α → α → Prop} [IsWellOrder α r] (x : α) :
    #{ y // r y x } = (typein r x).card 
Arguments: {α : Type u} {r : α → α → Prop} [IsWellOrder α r] (x : α)
Goal: #{ y // r y x } = (Ordinal.typein r x).card
-- Ordinal.card_le_card
theorem card_le_card {o₁ o₂ : Ordinal} : o₁ ≤ o₂ → card o₁ ≤ card o₂ 
Arguments: {o₁ o₂ : Ordinal.{u_3}}
Goal: o₁ ≤ o₂ → o₁.card ≤ o₂.card
-- Ordinal.card_zero
@[simp]
theorem card_zero : card 0 = 0 
Goal: Ordinal.card 0 = 0
-- Ordinal.card_one
@[simp]
theorem card_one : card 1 = 1 
Goal: Ordinal.card 1 = 1
-- Ordinal.type_uLift
theorem type_uLift (r : α → α → Prop) [IsWellOrder α r] :
    type (ULift.down.{v,u} ⁻¹'o r) = lift.{v} (type r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r]
Goal: Ordinal.type (ULift.down ⁻¹'o r) = Ordinal.lift.{v, u} (Ordinal.type r)
-- Ordinal.type_uLift_aux
@[simp, nolint simpNF]
theorem type_uLift_aux (r : α → α → Prop) [IsWellOrder α r] :
    @type.{max v u} _ (fun x y => r (ULift.down.{v,u} x) (ULift.down.{v,u} y))
      (inferInstanceAs (IsWellOrder (ULift α) (ULift.down ⁻¹'o r))) = lift.{v} (type r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r]
Goal: (Ordinal.type fun x y => r x.down y.down) = Ordinal.lift.{v, u} (Ordinal.type r)
-- RelIso.ordinal_lift_type_eq
theorem _root_.RelIso.ordinal_lift_type_eq {α : Type u} {β : Type v} {r : α → α → Prop}
    {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (f : r ≃r s) :
    lift.{v} (type r) = lift.{u} (type s) 
Arguments: {α : Type u} {β : Type v} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s] (f : r ≃r s)
Goal: Ordinal.lift.{v, u} (Ordinal.type r) = Ordinal.lift.{u, v} (Ordinal.type s)
-- Ordinal.type_lift_preimage
theorem type_lift_preimage {α : Type u} {β : Type v} (r : α → α → Prop) [IsWellOrder α r]
    (f : β ≃ α) : lift.{u} (type (f ⁻¹'o r)) = lift.{v} (type r) 
Arguments: {α : Type u} {β : Type v} (r : α → α → Prop) [IsWellOrder α r] (f : β ≃ α)
Goal: Ordinal.lift.{u, v} (Ordinal.type (⇑f ⁻¹'o r)) = Ordinal.lift.{v, u} (Ordinal.type r)
-- Ordinal.type_lift_preimage_aux
@[simp, nolint simpNF]
theorem type_lift_preimage_aux {α : Type u} {β : Type v} (r : α → α → Prop) [IsWellOrder α r]
    (f : β ≃ α) : lift.{u} (@type _ (fun x y => r (f x) (f y))
      (inferInstanceAs (IsWellOrder β (f ⁻¹'o r)))) = lift.{v} (type r) 
Arguments: {α : Type u} {β : Type v} (r : α → α → Prop) [IsWellOrder α r] (f : β ≃ α)
Goal: Ordinal.lift.{u, v} (Ordinal.type fun x y => r (f x) (f y)) = Ordinal.lift.{v, u} (Ordinal.type r)
-- Ordinal.lift_umax
-- @[simp] -- Porting note: simp lemma never applies, tested
theorem lift_umax : lift.{max u v, u} = lift.{v, u} 
Goal: Ordinal.lift.{max u v, u} = Ordinal.lift.{v, u}
-- Ordinal.lift_umax'
-- @[simp] -- Porting note: simp lemma never applies, tested
theorem lift_umax' : lift.{max v u, u} = lift.{v, u} 
Goal: Ordinal.lift.{max v u, u} = Ordinal.lift.{v, u}
-- Ordinal.lift_id'
-- @[simp] -- Porting note: simp lemma never applies, tested
theorem lift_id' (a : Ordinal) : lift a = a 
Arguments: (a : Ordinal.{max u_3 u_4})
Goal: Ordinal.lift.{u_3, max u_3 u_4} a = a
-- Ordinal.lift_id
@[simp]
theorem lift_id : ∀ a, lift.{u, u} a = a 
Arguments: (a : Ordinal.{u})
Goal: Ordinal.lift.{u, u} a = a
-- Ordinal.lift_uzero
@[simp]
theorem lift_uzero (a : Ordinal.{u}) : lift.{0} a = a 
Arguments: (a : Ordinal.{u})
Goal: Ordinal.lift.{0, u} a = a
-- Ordinal.lift_lift
@[simp]
theorem lift_lift (a : Ordinal) : lift.{w} (lift.{v} a) = lift.{max v w} a 
Arguments: (a : Ordinal.{u_3})
Goal: Ordinal.lift.{w, max v u_3} (Ordinal.lift.{v, u_3} a) = Ordinal.lift.{max v w, u_3} a
-- Ordinal.lift_type_le
theorem lift_type_le {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
    lift.{max v w} (type r) ≤ lift.{max u w} (type s) ↔ Nonempty (r ≼i s) 
Arguments: {α : Type u} {β : Type v} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.lift.{max v w, u} (Ordinal.type r) ≤ Ordinal.lift.{max u w, v} (Ordinal.type s) ↔ Nonempty (r ≼i s)
-- Ordinal.lift_type_eq
theorem lift_type_eq {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
    lift.{max v w} (type r) = lift.{max u w} (type s) ↔ Nonempty (r ≃r s) 
Arguments: {α : Type u} {β : Type v} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.lift.{max v w, u} (Ordinal.type r) = Ordinal.lift.{max u w, v} (Ordinal.type s) ↔ Nonempty (r ≃r s)
-- Ordinal.lift_type_lt
theorem lift_type_lt {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
    lift.{max v w} (type r) < lift.{max u w} (type s) ↔ Nonempty (r ≺i s) 
Arguments: {α : Type u} {β : Type v} {r : α → α → Prop} {s : β → β → Prop} [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.lift.{max v w, u} (Ordinal.type r) < Ordinal.lift.{max u w, v} (Ordinal.type s) ↔ Nonempty (r ≺i s)
-- Ordinal.lift_le
@[simp]
theorem lift_le {a b : Ordinal} : lift.{u,v} a ≤ lift.{u,v} b ↔ a ≤ b 
Arguments: {a b : Ordinal.{v}}
Goal: Ordinal.lift.{u, v} a ≤ Ordinal.lift.{u, v} b ↔ a ≤ b
-- Ordinal.lift_inj
@[simp]
theorem lift_inj {a b : Ordinal} : lift.{u,v} a = lift.{u,v} b ↔ a = b 
Arguments: {a b : Ordinal.{v}}
Goal: Ordinal.lift.{u, v} a = Ordinal.lift.{u, v} b ↔ a = b
-- Ordinal.lift_lt
@[simp]
theorem lift_lt {a b : Ordinal} : lift.{u,v} a < lift.{u,v} b ↔ a < b 
Arguments: {a b : Ordinal.{v}}
Goal: Ordinal.lift.{u, v} a < Ordinal.lift.{u, v} b ↔ a < b
-- Ordinal.lift_zero
@[simp]
theorem lift_zero : lift 0 = 0 
Goal: Ordinal.lift.{u_4, u_3} 0 = 0
-- Ordinal.lift_one
@[simp]
theorem lift_one : lift 1 = 1 
Goal: Ordinal.lift.{u_4, u_3} 1 = 1
-- Ordinal.lift_card
@[simp]
theorem lift_card (a) : Cardinal.lift.{u,v} (card a)= card (lift.{u,v} a) 
Arguments: (a : Ordinal.{v})
Goal: Cardinal.lift.{u, v} a.card = (Ordinal.lift.{u, v} a).card
-- Ordinal.lift_down'
theorem lift_down' {a : Cardinal.{u}} {b : Ordinal.{max u v}}
    (h : card.{max u v} b ≤ Cardinal.lift.{v,u} a) : ∃ a', lift.{v,u} a' = b 
Arguments: {a : Cardinal.{u}} {b : Ordinal.{max u v}} (h : b.card ≤ Cardinal.lift.{v, u} a)
Goal: ∃ a', Ordinal.lift.{v, u} a' = b
-- Ordinal.lift_down
theorem lift_down {a : Ordinal.{u}} {b : Ordinal.{max u v}} (h : b ≤ lift.{v,u} a) :
    ∃ a', lift.{v,u} a' = b 
Arguments: {a : Ordinal.{u}} {b : Ordinal.{max u v}} (h : b ≤ Ordinal.lift.{v, u} a)
Goal: ∃ a', Ordinal.lift.{v, u} a' = b
-- Ordinal.le_lift_iff
theorem le_lift_iff {a : Ordinal.{u}} {b : Ordinal.{max u v}} :
    b ≤ lift.{v,u} a ↔ ∃ a', lift.{v,u} a' = b ∧ a' ≤ a 
Arguments: {a : Ordinal.{u}} {b : Ordinal.{max u v}}
Goal: b ≤ Ordinal.lift.{v, u} a ↔ ∃ a', Ordinal.lift.{v, u} a' = b ∧ a' ≤ a
-- Ordinal.lt_lift_iff
theorem lt_lift_iff {a : Ordinal.{u}} {b : Ordinal.{max u v}} :
    b < lift.{v,u} a ↔ ∃ a', lift.{v,u} a' = b ∧ a' < a 
Arguments: {a : Ordinal.{u}} {b : Ordinal.{max u v}}
Goal: b < Ordinal.lift.{v, u} a ↔ ∃ a', Ordinal.lift.{v, u} a' = b ∧ a' < a
-- Ordinal.lift.initialSeg_coe
@[simp]
theorem lift.initialSeg_coe : (lift.initialSeg.{u,v} : Ordinal → Ordinal) = lift.{v,u} 
Goal: ⇑Ordinal.lift.initialSeg = Ordinal.lift.{v, u}
-- Ordinal.type_nat_lt
@[simp]
theorem type_nat_lt : @type ℕ (· < ·) _ = ω 
Goal: (Ordinal.type fun x x_1 => x < x_1) = Ordinal.omega
-- Ordinal.card_omega
@[simp]
theorem card_omega : card ω = ℵ₀ 
Goal: Ordinal.omega.card = ℵ₀
-- Ordinal.lift_omega
@[simp]
theorem lift_omega : lift ω = ω 
Goal: Ordinal.lift.{u_3, u_4} Ordinal.omega = Ordinal.omega
-- Ordinal.card_add
@[simp]
theorem card_add (o₁ o₂ : Ordinal) : card (o₁ + o₂) = card o₁ + card o₂ 
Arguments: (o₁ o₂ : Ordinal.{u_3})
Goal: (o₁ + o₂).card = o₁.card + o₂.card
-- Ordinal.type_sum_lex
@[simp]
theorem type_sum_lex {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [IsWellOrder α r]
    [IsWellOrder β s] : type (Sum.Lex r s) = type r + type s 
Arguments: {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [IsWellOrder α r] [IsWellOrder β s]
Goal: Ordinal.type (Sum.Lex r s) = Ordinal.type r + Ordinal.type s
-- Ordinal.card_nat
@[simp]
theorem card_nat (n : ℕ) : card.{u} n = n 
Arguments: (n : ℕ)
Goal: (↑n).card = ↑n
-- Ordinal.card_ofNat
@[simp]
theorem card_ofNat (n : ℕ) [n.AtLeastTwo] :
    card.{u} (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).card = OfNat.ofNat n
-- Ordinal.le_add_right
theorem le_add_right (a b : Ordinal) : a ≤ a + b 
Arguments: (a b : Ordinal.{u_3})
Goal: a ≤ a + b
-- Ordinal.le_add_left
theorem le_add_left (a b : Ordinal) : a ≤ b + a 
Arguments: (a b : Ordinal.{u_3})
Goal: a ≤ b + a
-- Ordinal.max_zero_left
theorem max_zero_left : ∀ a : Ordinal, max 0 a = a 
Arguments: (a : Ordinal.{u_3})
Goal: max 0 a = a
-- Ordinal.max_zero_right
theorem max_zero_right : ∀ a : Ordinal, max a 0 = a 
Arguments: (a : Ordinal.{u_3})
Goal: max a 0 = a
-- Ordinal.max_eq_zero
@[simp]
theorem max_eq_zero {a b : Ordinal} : max a b = 0 ↔ a = 0 ∧ b = 0 
Arguments: {a b : Ordinal.{u_3}}
Goal: max a b = 0 ↔ a = 0 ∧ b = 0
-- Ordinal.sInf_empty
@[simp]
theorem sInf_empty : sInf (∅ : Set Ordinal) = 0 
Goal: sInf ∅ = 0
-- _private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.succ_le_iff'
private theorem succ_le_iff' {a b : Ordinal} : a + 1 ≤ b ↔ a < b 
Arguments: {a b : Ordinal.{u_3}}
Goal: a + 1 ≤ b ↔ a < b
-- Ordinal.add_one_eq_succ
@[simp]
theorem add_one_eq_succ (o : Ordinal) : o + 1 = succ o 
Arguments: (o : Ordinal.{u_3})
Goal: o + 1 = Order.succ o
-- Ordinal.succ_zero
@[simp]
theorem succ_zero : succ (0 : Ordinal) = 1 
Goal: Order.succ 0 = 1
-- Ordinal.succ_one
@[simp]
theorem succ_one : succ (1 : Ordinal) = 2 
Goal: Order.succ 1 = 2
-- Ordinal.add_succ
theorem add_succ (o₁ o₂ : Ordinal) : o₁ + succ o₂ = succ (o₁ + o₂) 
Arguments: (o₁ o₂ : Ordinal.{u_3})
Goal: o₁ + Order.succ o₂ = Order.succ (o₁ + o₂)
-- Ordinal.one_le_iff_pos
theorem one_le_iff_pos {o : Ordinal} : 1 ≤ o ↔ 0 < o 
Arguments: {o : Ordinal.{u_3}}
Goal: 1 ≤ o ↔ 0 < o
-- Ordinal.one_le_iff_ne_zero
theorem one_le_iff_ne_zero {o : Ordinal} : 1 ≤ o ↔ o ≠ 0 
Arguments: {o : Ordinal.{u_3}}
Goal: 1 ≤ o ↔ o ≠ 0
-- Ordinal.succ_pos
theorem succ_pos (o : Ordinal) : 0 < succ o 
Arguments: (o : Ordinal.{u_3})
Goal: 0 < Order.succ o
-- Ordinal.succ_ne_zero
theorem succ_ne_zero (o : Ordinal) : succ o ≠ 0 
Arguments: (o : Ordinal.{u_3})
Goal: Order.succ o ≠ 0
-- Ordinal.lt_one_iff_zero
@[simp]
theorem lt_one_iff_zero {a : Ordinal} : a < 1 ↔ a = 0 
Arguments: {a : Ordinal.{u_3}}
Goal: a < 1 ↔ a = 0
-- Ordinal.le_one_iff
theorem le_one_iff {a : Ordinal} : a ≤ 1 ↔ a = 0 ∨ a = 1 
Arguments: {a : Ordinal.{u_3}}
Goal: a ≤ 1 ↔ a = 0 ∨ a = 1
-- Ordinal.card_succ
@[simp]
theorem card_succ (o : Ordinal) : card (succ o) = card o + 1 
Arguments: (o : Ordinal.{u_3})
Goal: (Order.succ o).card = o.card + 1
-- Ordinal.natCast_succ
theorem natCast_succ (n : ℕ) : ↑n.succ = succ (n : Ordinal) 
Arguments: (n : ℕ)
Goal: ↑n.succ = Order.succ ↑n
-- Ordinal.one_out_eq
theorem one_out_eq (x : (1 : Ordinal).out.α) : x = enum (· < ·) 0 (by simp) 
Arguments: (x : (Quotient.out 1).α)
Goal: x = Ordinal.enum (fun x x_1 => x < x_1) 0 ⋯
-- Ordinal.typein_one_out
@[simp]
theorem typein_one_out (x : (1 : Ordinal).out.α) :
    @typein _ (· < ·) (isWellOrder_out_lt _) x = 0 
Arguments: (x : (Quotient.out 1).α)
Goal: Ordinal.typein (fun x x_1 => x < x_1) x = 0
-- Ordinal.typein_le_typein
@[simp]
theorem typein_le_typein (r : α → α → Prop) [IsWellOrder α r] {x x' : α} :
    typein r x ≤ typein r x' ↔ ¬r x' x 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] {x x' : α}
Goal: Ordinal.typein r x ≤ Ordinal.typein r x' ↔ ¬r x' x
-- Ordinal.typein_le_typein'
theorem typein_le_typein' (o : Ordinal) {x x' : o.out.α} :
    @typein _ (· < ·) (isWellOrder_out_lt _) x ≤ @typein _ (· < ·) (isWellOrder_out_lt _) x'
      ↔ x ≤ x' 
Arguments: (o : Ordinal.{u_3}) {x x' : (Quotient.out o).α}
Goal: Ordinal.typein (fun x x_1 => x < x_1) x ≤ Ordinal.typein (fun x x_1 => x < x_1) x' ↔ x ≤ x'
-- Ordinal.enum_le_enum
@[simp, nolint simpNF]
theorem enum_le_enum (r : α → α → Prop) [IsWellOrder α r] {o o' : Ordinal} (ho : o < type r)
    (ho' : o' < type r) : ¬r (enum r o' ho') (enum r o ho) ↔ o ≤ o' 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] {o o' : Ordinal.{u}} (ho : o < Ordinal.type r) (ho' : o' < Ordinal.type r)
Goal: ¬r (Ordinal.enum r o' ho') (Ordinal.enum r o ho) ↔ o ≤ o'
-- Ordinal.enum_le_enum'
@[simp]
theorem enum_le_enum' (a : Ordinal) {o o' : Ordinal} (ho : o < type (· < ·))
    (ho' : o' < type (· < ·)) : enum (· < ·) o ho ≤ @enum a.out.α (· < ·) _ o' ho' ↔ o ≤ o' 
Arguments: (a : Ordinal.{u_3}) {o o' : Ordinal.{u_3}} (ho : o < Ordinal.type fun x x_1 => x < x_1) (ho' : o' < Ordinal.type fun x x_1 => x < x_1)
Goal: Ordinal.enum (fun x x_1 => x < x_1) o ho ≤ Ordinal.enum (fun x x_1 => x < x_1) o' ho' ↔ o ≤ o'
-- Ordinal.enum_zero_le
theorem enum_zero_le {r : α → α → Prop} [IsWellOrder α r] (h0 : 0 < type r) (a : α) :
    ¬r a (enum r 0 h0) 
Arguments: {α : Type u} {r : α → α → Prop} [IsWellOrder α r] (h0 : 0 < Ordinal.type r) (a : α)
Goal: ¬r a (Ordinal.enum r 0 h0)
-- Ordinal.enum_zero_le'
theorem enum_zero_le' {o : Ordinal} (h0 : 0 < o) (a : o.out.α) :
    @enum o.out.α (· < ·) _ 0 (by rwa [type_lt]) ≤ a 
Arguments: {o : Ordinal.{u_3}} (h0 : 0 < o) (a : (Quotient.out o).α)
Goal: Ordinal.enum (fun x x_1 => x < x_1) 0 ⋯ ≤ a
-- Ordinal.le_enum_succ
theorem le_enum_succ {o : Ordinal} (a : (succ o).out.α) :
    a ≤
      @enum (succ o).out.α (· < ·) _ o
        (by
          rw [type_lt]
          exact lt_succ o) 
Arguments: {o : Ordinal.{u_3}} (a : (Quotient.out (Order.succ o)).α)
Goal: a ≤ Ordinal.enum (fun x x_1 => x < x_1) o ⋯
-- Ordinal.enum_inj
@[simp]
theorem enum_inj {r : α → α → Prop} [IsWellOrder α r] {o₁ o₂ : Ordinal} (h₁ : o₁ < type r)
    (h₂ : o₂ < type r) : enum r o₁ h₁ = enum r o₂ h₂ ↔ o₁ = o₂ 
Arguments: {α : Type u} {r : α → α → Prop} [IsWellOrder α r] {o₁ o₂ : Ordinal.{u}} (h₁ : o₁ < Ordinal.type r) (h₂ : o₂ < Ordinal.type r)
Goal: Ordinal.enum r o₁ h₁ = Ordinal.enum r o₂ h₂ ↔ o₁ = o₂
-- Ordinal.enumIso_symm_apply_coe
@[simps]
def enumIso (r : α → α → Prop) [IsWellOrder α r] : Subrel (· < ·) (· < type r) ≃r r 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] (x : α)
Goal: ↑((Ordinal.enumIso r).symm x) = Ordinal.typein r x
-- Ordinal.enumIso_apply
@[simps]
def enumIso (r : α → α → Prop) [IsWellOrder α r] : Subrel (· < ·) (· < type r) ≃r r 
Arguments: {α : Type u} (r : α → α → Prop) [IsWellOrder α r] (x : ↑fun x => x < Ordinal.type r)
Goal: (Ordinal.enumIso r) x = Ordinal.enum r ↑x ⋯
-- Ordinal.enumIsoOut_apply
@[simps!]
noncomputable def enumIsoOut (o : Ordinal) : Set.Iio o ≃o o.out.α 
Arguments: (o : Ordinal.{u_3}) (x : ↑(Set.Iio o))
Goal: o.enumIsoOut x = Ordinal.enum (fun x x_1 => x < x_1) ↑x ⋯
-- Ordinal.enumIsoOut_symm_apply_coe
@[simps!]
noncomputable def enumIsoOut (o : Ordinal) : Set.Iio o ≃o o.out.α 
Arguments: (o : Ordinal.{u_3}) (x : (Quotient.out o).α)
Goal: ↑((RelIso.symm o.enumIsoOut) x) = Ordinal.typein (fun x x_1 => x < x_1) x
-- Ordinal.enum_zero_eq_bot
theorem enum_zero_eq_bot {o : Ordinal} (ho : 0 < o) :
    enum (· < ·) 0 (by rwa [type_lt]) =
      haveI H := outOrderBotOfPos ho
      (⊥ : (Quotient.out o).α) 
Arguments: {o : Ordinal.{u_3}} (ho : 0 < o)
Goal: Ordinal.enum (fun x x_1 => x < x_1) 0 ⋯ = ⊥
-- Ordinal.univ_id
theorem univ_id : univ.{u, u + 1} = @type Ordinal (· < ·) _ 
Goal: Ordinal.univ.{u, u + 1} = Ordinal.type fun x x_1 => x < x_1
-- Ordinal.lift_univ
@[simp]
theorem lift_univ : lift.{w} univ.{u, v} = univ.{u, max v w} 
Goal: Ordinal.lift.{w, max (u + 1) v} Ordinal.univ.{u, v} = Ordinal.univ.{u, max v w}
-- Ordinal.univ_umax
theorem univ_umax : univ.{u, max (u + 1) v} = univ.{u, v} 
Goal: Ordinal.univ.{u, max (u + 1) v} = Ordinal.univ.{u, v}
-- Ordinal.lift.principalSeg_coe
@[simp]
theorem lift.principalSeg_coe :
    (lift.principalSeg.{u, v} : Ordinal → Ordinal) = lift.{max (u + 1) v} 
Goal: ⇑Ordinal.lift.principalSeg.toRelEmbedding = Ordinal.lift.{max (u + 1) v, u}