ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Ordinal.mem_closed_iff_sup
theorem mem_closed_iff_sup (hs : IsClosed s) :
    a ∈ s ↔ ∃ (ι : Type u) (_hι : Nonempty ι) (f : ι → Ordinal),
      (∀ i, f i ∈ s) ∧ sup.{u, u} f = a 
Arguments: {s : Set Ordinal.{u}} {a : Ordinal.{u}} (hs : IsClosed s)
Goal: a ∈ s ↔ ∃ ι, ∃ (_ : Nonempty ι), ∃ f, (∀ (i : ι), f i ∈ s) ∧ Ordinal.sup f = a
-- Ordinal.mem_closure_iff_bsup
theorem mem_closure_iff_bsup :
    a ∈ closure s ↔
      ∃ (o : Ordinal) (_ho : o ≠ 0) (f : ∀ a < o, Ordinal),
        (∀ i hi, f i hi ∈ s) ∧ bsup.{u, u} o f = a 
Arguments: {s : Set Ordinal.{u}} {a : Ordinal.{u}}
Goal: a ∈ closure s ↔ ∃ o, ∃ (_ : o ≠ 0), ∃ f, (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) ∧ o.bsup f = a
-- Ordinal.mem_closed_iff_bsup
theorem mem_closed_iff_bsup (hs : IsClosed s) :
    a ∈ s ↔
      ∃ (o : Ordinal) (_ho : o ≠ 0) (f : ∀ a < o, Ordinal),
        (∀ i hi, f i hi ∈ s) ∧ bsup.{u, u} o f = a 
Arguments: {s : Set Ordinal.{u}} {a : Ordinal.{u}} (hs : IsClosed s)
Goal: a ∈ s ↔ ∃ o, ∃ (_ : o ≠ 0), ∃ f, (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) ∧ o.bsup f = a
-- Ordinal.isClosed_iff_sup
theorem isClosed_iff_sup :
    IsClosed s ↔
      ∀ {ι : Type u}, Nonempty ι → ∀ f : ι → Ordinal, (∀ i, f i ∈ s) → sup.{u, u} f ∈ s 
Arguments: {s : Set Ordinal.{u}}
Goal: IsClosed s ↔ ∀ {ι : Type u}, Nonempty ι → ∀ (f : ι → Ordinal.{u}), (∀ (i : ι), f i ∈ s) → Ordinal.sup f ∈ s
-- Ordinal.isClosed_iff_bsup
theorem isClosed_iff_bsup :
    IsClosed s ↔
      ∀ {o : Ordinal}, o ≠ 0 → ∀ f : ∀ a < o, Ordinal,
        (∀ i hi, f i hi ∈ s) → bsup.{u, u} o f ∈ s 
Arguments: {s : Set Ordinal.{u}}
Goal: IsClosed s ↔
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
-- Ordinal.isLimit_of_mem_frontier
theorem isLimit_of_mem_frontier (ha : a ∈ frontier s) : IsLimit a 
Arguments: {s : Set Ordinal.{u}} {a : Ordinal.{u}} (ha : a ∈ frontier s)
Goal: a.IsLimit
-- Ordinal.isNormal_iff_strictMono_and_continuous
theorem isNormal_iff_strictMono_and_continuous (f : Ordinal.{u} → Ordinal.{u}) :
    IsNormal f ↔ StrictMono f ∧ Continuous f 
Arguments: (f : Ordinal.{u} → Ordinal.{u})
Goal: Ordinal.IsNormal f ↔ StrictMono f ∧ Continuous f
-- Ordinal.enumOrd_isNormal_iff_isClosed
theorem enumOrd_isNormal_iff_isClosed (hs : s.Unbounded (· < ·)) :
    IsNormal (enumOrd s) ↔ IsClosed s 
Arguments: {s : Set Ordinal.{u}} (hs : Set.Unbounded (fun x x_1 => x < x_1) s)
Goal: Ordinal.IsNormal (Ordinal.enumOrd s) ↔ IsClosed s
-- Quiver.Hom.cast_eq_cast
theorem Hom.cast_eq_cast {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v) :
    e.cast hu hv = _root_.cast (by {rw [hu, hv]}) e 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v)
Goal: Quiver.Hom.cast hu hv e = cast ⋯ e
-- Quiver.Hom.cast_rfl_rfl
@[simp]
theorem Hom.cast_rfl_rfl {u v : U} (e : u ⟶ v) : e.cast rfl rfl = e 
Arguments: {U : Type u_1} [Quiver U] {u v : U} (e : u ⟶ v)
Goal: Quiver.Hom.cast ⋯ ⋯ e = e
-- Quiver.Hom.cast_cast
@[simp]
theorem Hom.cast_cast {u v u' v' u'' v'' : U} (e : u ⟶ v) (hu : u = u') (hv : v = v')
    (hu' : u' = u'') (hv' : v' = v'') :
    (e.cast hu hv).cast hu' hv' = e.cast (hu.trans hu') (hv.trans hv') 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' u'' v'' : U} (e : u ⟶ v) (hu : u = u') (hv : v = v') (hu' : u' = u'') (hv' : v' = v'')
Goal: Quiver.Hom.cast hu' hv' (Quiver.Hom.cast hu hv e) = Quiver.Hom.cast ⋯ ⋯ e
-- Quiver.Hom.cast_heq
theorem Hom.cast_heq {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v) :
    HEq (e.cast hu hv) e 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v)
Goal: HEq (Quiver.Hom.cast hu hv e) e
-- Quiver.Hom.cast_eq_iff_heq
theorem Hom.cast_eq_iff_heq {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v) (e' : u' ⟶ v') :
    e.cast hu hv = e' ↔ HEq e e' 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v) (e' : u' ⟶ v')
Goal: Quiver.Hom.cast hu hv e = e' ↔ HEq e e'
-- Quiver.Hom.eq_cast_iff_heq
theorem Hom.eq_cast_iff_heq {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v) (e' : u' ⟶ v') :
    e' = e.cast hu hv ↔ HEq e' e 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v) (e' : u' ⟶ v')
Goal: e' = Quiver.Hom.cast hu hv e ↔ HEq e' e
-- Quiver.Path.cast_eq_cast
theorem Path.cast_eq_cast {u v u' v' : U} (hu : u = u') (hv : v = v') (p : Path u v) :
    p.cast hu hv = _root_.cast (by rw [hu, hv]) p 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' : U} (hu : u = u') (hv : v = v') (p : Quiver.Path u v)
Goal: Quiver.Path.cast hu hv p = cast ⋯ p
-- Quiver.Path.cast_rfl_rfl
@[simp]
theorem Path.cast_rfl_rfl {u v : U} (p : Path u v) : p.cast rfl rfl = p 
Arguments: {U : Type u_1} [Quiver U] {u v : U} (p : Quiver.Path u v)
Goal: Quiver.Path.cast ⋯ ⋯ p = p
-- Quiver.Path.cast_cast
@[simp]
theorem Path.cast_cast {u v u' v' u'' v'' : U} (p : Path u v) (hu : u = u') (hv : v = v')
    (hu' : u' = u'') (hv' : v' = v'') :
    (p.cast hu hv).cast hu' hv' = p.cast (hu.trans hu') (hv.trans hv') 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' u'' v'' : U} (p : Quiver.Path u v) (hu : u = u') (hv : v = v') (hu' : u' = u'') (hv' : v' = v'')
Goal: Quiver.Path.cast hu' hv' (Quiver.Path.cast hu hv p) = Quiver.Path.cast ⋯ ⋯ p
-- Quiver.Path.cast_nil
@[simp]
theorem Path.cast_nil {u u' : U} (hu : u = u') : (Path.nil : Path u u).cast hu hu = Path.nil 
Arguments: {U : Type u_1} [Quiver U] {u u' : U} (hu : u = u')
Goal: Quiver.Path.cast hu hu Quiver.Path.nil = Quiver.Path.nil
-- Quiver.Path.cast_heq
theorem Path.cast_heq {u v u' v' : U} (hu : u = u') (hv : v = v') (p : Path u v) :
    HEq (p.cast hu hv) p 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' : U} (hu : u = u') (hv : v = v') (p : Quiver.Path u v)
Goal: HEq (Quiver.Path.cast hu hv p) p
-- Quiver.Path.cast_eq_iff_heq
theorem Path.cast_eq_iff_heq {u v u' v' : U} (hu : u = u') (hv : v = v') (p : Path u v)
    (p' : Path u' v') : p.cast hu hv = p' ↔ HEq p p' 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' : U} (hu : u = u') (hv : v = v') (p : Quiver.Path u v) (p' : Quiver.Path u' v')
Goal: Quiver.Path.cast hu hv p = p' ↔ HEq p p'
-- Quiver.Path.eq_cast_iff_heq
theorem Path.eq_cast_iff_heq {u v u' v' : U} (hu : u = u') (hv : v = v') (p : Path u v)
    (p' : Path u' v') : p' = p.cast hu hv ↔ HEq p' p 
Arguments: {U : Type u_1} [Quiver U] {u v u' v' : U} (hu : u = u') (hv : v = v') (p : Quiver.Path u v) (p' : Quiver.Path u' v')
Goal: p' = Quiver.Path.cast hu hv p ↔ HEq p' p
-- Quiver.Path.cast_cons
theorem Path.cast_cons {u v w u' w' : U} (p : Path u v) (e : v ⟶ w) (hu : u = u') (hw : w = w') :
    (p.cons e).cast hu hw = (p.cast hu rfl).cons (e.cast rfl hw) 
Arguments: {U : Type u_1} [Quiver U] {u v w u' w' : U} (p : Quiver.Path u v) (e : v ⟶ w) (hu : u = u') (hw : w = w')
Goal: Quiver.Path.cast hu hw (p.cons e) = (Quiver.Path.cast hu ⋯ p).cons (Quiver.Hom.cast ⋯ hw e)
-- Quiver.cast_eq_of_cons_eq_cons
theorem cast_eq_of_cons_eq_cons {u v v' w : U} {p : Path u v} {p' : Path u v'} {e : v ⟶ w}
    {e' : v' ⟶ w} (h : p.cons e = p'.cons e') : p.cast rfl (obj_eq_of_cons_eq_cons h) = p' 
Arguments: {U : Type u_1} [Quiver U] {u v v' w : U} {p : Quiver.Path u v} {p' : Quiver.Path u v'} {e : v ⟶ w} {e' : v' ⟶ w} (h : p.cons e = p'.cons e')
Goal: Quiver.Path.cast ⋯ ⋯ p = p'
-- Quiver.hom_cast_eq_of_cons_eq_cons
theorem hom_cast_eq_of_cons_eq_cons {u v v' w : U} {p : Path u v} {p' : Path u v'} {e : v ⟶ w}
    {e' : v' ⟶ w} (h : p.cons e = p'.cons e') : e.cast (obj_eq_of_cons_eq_cons h) rfl = e' 
Arguments: {U : Type u_1} [Quiver U] {u v v' w : U} {p : Quiver.Path u v} {p' : Quiver.Path u v'} {e : v ⟶ w} {e' : v' ⟶ w} (h : p.cons e = p'.cons e')
Goal: Quiver.Hom.cast ⋯ ⋯ e = e'
-- Quiver.eq_nil_of_length_zero
theorem eq_nil_of_length_zero {u v : U} (p : Path u v) (hzero : p.length = 0) :
    p.cast (eq_of_length_zero p hzero) rfl = Path.nil 
Arguments: {U : Type u_1} [Quiver U] {u v : U} (p : Quiver.Path u v) (hzero : p.length = 0)
Goal: Quiver.Path.cast ⋯ ⋯ p = Quiver.Path.nil
-- Quiver.HasInvolutiveReverse.inv'
class HasInvolutiveReverse extends HasReverse V where
    inv' : ∀ {a b : V} (f : a ⟶ b), reverse (reverse f) = f
Arguments: {V : Type u_2} [Quiver V] [self : Quiver.HasInvolutiveReverse V] {a b : V} (f : a ⟶ b)
Goal: Quiver.reverse (Quiver.reverse f) = f
-- Quiver.reverse_reverse
@[simp]
theorem reverse_reverse [h : HasInvolutiveReverse V] {a b : V} (f : a ⟶ b) :
    reverse (reverse f) = f 
Arguments: {V : Type u_2} [Quiver V] [h : Quiver.HasInvolutiveReverse V] {a b : V} (f : a ⟶ b)
Goal: Quiver.reverse (Quiver.reverse f) = f
-- Quiver.reverse_inj
@[simp]
theorem reverse_inj [h : HasInvolutiveReverse V] {a b : V}
    (f g : a ⟶ b) : reverse f = reverse g ↔ f = g 
Arguments: {V : Type u_2} [Quiver V] [h : Quiver.HasInvolutiveReverse V] {a b : V} (f g : a ⟶ b)
Goal: Quiver.reverse f = Quiver.reverse g ↔ f = g
-- Quiver.eq_reverse_iff
theorem eq_reverse_iff [h : HasInvolutiveReverse V] {a b : V} (f : a ⟶ b)
    (g : b ⟶ a) : f = reverse g ↔ reverse f = g 
Arguments: {V : Type u_2} [Quiver V] [h : Quiver.HasInvolutiveReverse V] {a b : V} (f : a ⟶ b) (g : b ⟶ a)
Goal: f = Quiver.reverse g ↔ Quiver.reverse f = g
-- Prefunctor.MapReverse.map_reverse'
class _root_.Prefunctor.MapReverse (φ : U ⥤q V) : Prop where
    map_reverse' : ∀ {u v : U} (e : u ⟶ v), φ.map (reverse e) = reverse (φ.map e)
Arguments: {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] [Quiver.HasReverse U] [Quiver.HasReverse V] {φ : U ⥤q V} [self : φ.MapReverse] {u v : U} (e : u ⟶ v)
Goal: φ.map (Quiver.reverse e) = Quiver.reverse (φ.map e)
-- Prefunctor.map_reverse
@[simp]
theorem _root_.Prefunctor.map_reverse (φ : U ⥤q V) [φ.MapReverse]
    {u v : U} (e : u ⟶ v) : φ.map (reverse e) = reverse (φ.map e) 
Arguments: {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] [Quiver.HasReverse U] [Quiver.HasReverse V] (φ : U ⥤q V) [φ.MapReverse] {u v : U} (e : u ⟶ v)
Goal: φ.map (Quiver.reverse e) = Quiver.reverse (φ.map e)
-- Quiver.symmetrify_reverse
@[simp]
theorem symmetrify_reverse {a b : Symmetrify V} (e : a ⟶ b) : reverse e = e.swap 
Arguments: {V : Type u_2} [Quiver V] {a b : Quiver.Symmetrify V} (e : a ⟶ b)
Goal: Quiver.reverse e = Sum.swap e
-- Quiver.Path.reverse_toPath
@[simp]
theorem Path.reverse_toPath [HasReverse V] {a b : V} (f : a ⟶ b) :
    f.toPath.reverse = (Quiver.reverse f).toPath 
Arguments: {V : Type u_2} [Quiver V] [Quiver.HasReverse V] {a b : V} (f : a ⟶ b)
Goal: f.toPath.reverse = (Quiver.reverse f).toPath
-- Quiver.Path.reverse_comp
@[simp]
theorem Path.reverse_comp [HasReverse V] {a b c : V} (p : Path a b) (q : Path b c) :
    (p.comp q).reverse = q.reverse.comp p.reverse 
Arguments: {V : Type u_2} [Quiver V] [Quiver.HasReverse V] {a b c : V} (p : Quiver.Path a b) (q : Quiver.Path b c)
Goal: (p.comp q).reverse = q.reverse.comp p.reverse
-- Quiver.Path.reverse_reverse
@[simp]
theorem Path.reverse_reverse [h : HasInvolutiveReverse V] {a b : V} (p : Path a b) :
    p.reverse.reverse = p 
Arguments: {V : Type u_2} [Quiver V] [h : Quiver.HasInvolutiveReverse V] {a b : V} (p : Quiver.Path a b)
Goal: p.reverse.reverse = p
-- Quiver.Symmetrify.lift_spec
theorem lift_spec [HasReverse V'] (φ : Prefunctor V V') :
    Symmetrify.of.comp (Symmetrify.lift φ) = φ 
Arguments: {V : Type u_2} [Quiver V] {V' : Type u_4} [Quiver V'] [Quiver.HasReverse V'] (φ : V ⥤q V')
Goal: Quiver.Symmetrify.of ⋙q Quiver.Symmetrify.lift φ = φ
-- Quiver.Symmetrify.lift_reverse
theorem lift_reverse [h : HasInvolutiveReverse V']
    (φ : Prefunctor V V') {X Y : Symmetrify V} (f : X ⟶ Y) :
    (Symmetrify.lift φ).map (Quiver.reverse f) = Quiver.reverse ((Symmetrify.lift φ).map f) 
Arguments: {V : Type u_2} [Quiver V] {V' : Type u_4} [Quiver V'] [h : Quiver.HasInvolutiveReverse V'] (φ : V ⥤q V') {X Y : Quiver.Symmetrify V} (f : X ⟶ Y)
Goal: (Quiver.Symmetrify.lift φ).map (Quiver.reverse f) = Quiver.reverse ((Quiver.Symmetrify.lift φ).map f)
-- Quiver.Symmetrify.lift_unique
theorem lift_unique [HasReverse V'] (φ : V ⥤q V') (Φ : Symmetrify V ⥤q V') (hΦ : (of ⋙q Φ) = φ)
    (hΦinv : ∀ {X Y : Symmetrify V} (f : X ⟶ Y),
      Φ.map (Quiver.reverse f) = Quiver.reverse (Φ.map f)) :
    Φ = Symmetrify.lift φ 
Arguments: {V : Type u_2} [Quiver V] {V' : Type u_4} [Quiver V'] [Quiver.HasReverse V'] (φ : V ⥤q V') (Φ : Quiver.Symmetrify V ⥤q V') (hΦ : Quiver.Symmetrify.of ⋙q Φ = φ) (hΦinv : ∀ {X Y : Quiver.Symmetrify V} (f : X ⟶ Y), Φ.map (Quiver.reverse f) = Quiver.reverse (Φ.map f))
Goal: Φ = Quiver.Symmetrify.lift φ
-- Prefunctor.symmetrify_map
@[simps]
def _root_.Prefunctor.symmetrify (φ : U ⥤q V) : Symmetrify U ⥤q Symmetrify V 
Arguments: {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] (φ : U ⥤q V)
Goal: ∀ {X Y : Quiver.Symmetrify U} (a : (X ⟶ Y) ⊕ (Y ⟶ X)), φ.symmetrify.map a = Sum.map φ.map φ.map a
-- Prefunctor.symmetrify_obj
@[simps]
def _root_.Prefunctor.symmetrify (φ : U ⥤q V) : Symmetrify U ⥤q Symmetrify V 
Arguments: {U : Type u_1} {V : Type u_2} [Quiver U] [Quiver V] (φ : U ⥤q V)
Goal: ∀ (a : U), φ.symmetrify.obj a = φ.obj a
-- Quiver.Push.of_reverse
theorem of_reverse [HasInvolutiveReverse V] (X Y : V) (f : X ⟶ Y) :
    (reverse <| (Push.of σ).map f) = (Push.of σ).map (reverse f) 
Arguments: {V : Type u_2} [Quiver V] {V' : Type u_4} (σ : V → V') [Quiver.HasInvolutiveReverse V] (X Y : V) (f : X ⟶ Y)
Goal: Quiver.reverse ((Quiver.Push.of σ).map f) = (Quiver.Push.of σ).map (Quiver.reverse f)
-- Ordinal.principal_iff_principal_swap
theorem principal_iff_principal_swap {op : Ordinal → Ordinal → Ordinal} {o : Ordinal} :
    Principal op o ↔ Principal (Function.swap op) o 
Arguments: {op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1}} {o : Ordinal.{u_1}}
Goal: Ordinal.Principal op o ↔ Ordinal.Principal (Function.swap op) o
-- Ordinal.principal_zero
theorem principal_zero {op : Ordinal → Ordinal → Ordinal} : Principal op 0 
Arguments: {op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1}}
Goal: Ordinal.Principal op 0
-- Ordinal.principal_one_iff
@[simp]
theorem principal_one_iff {op : Ordinal → Ordinal → Ordinal} : Principal op 1 ↔ op 0 0 = 0 
Arguments: {op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1}}
Goal: Ordinal.Principal op 1 ↔ op 0 0 = 0
-- Ordinal.Principal.iterate_lt
theorem Principal.iterate_lt {op : Ordinal → Ordinal → Ordinal} {a o : Ordinal} (hao : a < o)
    (ho : Principal op o) (n : ℕ) : (op a)^[n] a < o 
Arguments: {op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1}} {a o : Ordinal.{u_1}} (hao : a < o) (ho : Ordinal.Principal op o) (n : ℕ)
Goal: (op a)^[n] a < o
-- Ordinal.op_eq_self_of_principal
theorem op_eq_self_of_principal {op : Ordinal → Ordinal → Ordinal} {a o : Ordinal.{u}} (hao : a < o)
    (H : IsNormal (op a)) (ho : Principal op o) (ho' : IsLimit o) : op a o = o 
Arguments: {op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}} {a o : Ordinal.{u}} (hao : a < o) (H : Ordinal.IsNormal (op a)) (ho : Ordinal.Principal op o) (ho' : o.IsLimit)
Goal: op a o = o
-- Ordinal.nfp_le_of_principal
theorem nfp_le_of_principal {op : Ordinal → Ordinal → Ordinal} {a o : Ordinal} (hao : a < o)
    (ho : Principal op o) : nfp (op a) a ≤ o 
Arguments: {op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1}} {a o : Ordinal.{u_1}} (hao : a < o) (ho : Ordinal.Principal op o)
Goal: Ordinal.nfp (op a) a ≤ o
-- Ordinal.principal_nfp_blsub₂
theorem principal_nfp_blsub₂ (op : Ordinal → Ordinal → Ordinal) (o : Ordinal) :
    Principal op (nfp (fun o' => blsub₂.{u, u, u} o' o' (@fun a _ b _ => op a b)) o) 
Arguments: (op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}) (o : Ordinal.{u})
Goal: Ordinal.Principal op (Ordinal.nfp (fun o' => o'.blsub₂ o' fun a x b x => op a b) o)
-- Ordinal.unbounded_principal
theorem unbounded_principal (op : Ordinal → Ordinal → Ordinal) :
    Set.Unbounded (· < ·) { o | Principal op o } 
Arguments: (op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1})
Goal: Set.Unbounded (fun x x_1 => x < x_1) {o | Ordinal.Principal op o}
-- Ordinal.principal_add_one
theorem principal_add_one : Principal (· + ·) 1 
Goal: Ordinal.Principal (fun x x_1 => x + x_1) 1
-- Ordinal.principal_add_of_le_one
theorem principal_add_of_le_one {o : Ordinal} (ho : o ≤ 1) : Principal (· + ·) o 
Arguments: {o : Ordinal.{u_1}} (ho : o ≤ 1)
Goal: Ordinal.Principal (fun x x_1 => x + x_1) o
-- Ordinal.principal_add_isLimit
theorem principal_add_isLimit {o : Ordinal} (ho₁ : 1 < o) (ho : Principal (· + ·) o) :
    o.IsLimit 
Arguments: {o : Ordinal.{u_1}} (ho₁ : 1 < o) (ho : Ordinal.Principal (fun x x_1 => x + x_1) o)
Goal: o.IsLimit
-- Ordinal.principal_add_iff_add_left_eq_self
theorem principal_add_iff_add_left_eq_self {o : Ordinal} :
    Principal (· + ·) o ↔ ∀ a < o, a + o = o 
Arguments: {o : Ordinal.{u_1}}
Goal: Ordinal.Principal (fun x x_1 => x + x_1) o ↔ ∀ a < o, a + o = o
-- Ordinal.exists_lt_add_of_not_principal_add
theorem exists_lt_add_of_not_principal_add {a} (ha : ¬Principal (· + ·) a) :
    ∃ b c, b < a ∧ c < a ∧ b + c = a 
Arguments: {a : Ordinal.{u_1}} (ha : ¬Ordinal.Principal (fun x x_1 => x + x_1) a)
Goal: ∃ b c, b < a ∧ c < a ∧ b + c = a
-- Ordinal.principal_add_iff_add_lt_ne_self
theorem principal_add_iff_add_lt_ne_self {a} :
    Principal (· + ·) a ↔ ∀ ⦃b c⦄, b < a → c < a → b + c ≠ a 
Arguments: {a : Ordinal.{u_1}}
Goal: Ordinal.Principal (fun x x_1 => x + x_1) a ↔ ∀ ⦃b c : Ordinal.{u_1}⦄, b < a → c < a → b + c ≠ a
-- Ordinal.add_omega
theorem add_omega {a : Ordinal} (h : a < omega) : a + omega = omega 
Arguments: {a : Ordinal.{u_1}} (h : a < Ordinal.omega)
Goal: a + Ordinal.omega = Ordinal.omega
-- Ordinal.principal_add_omega
theorem principal_add_omega : Principal (· + ·) omega 
Goal: Ordinal.Principal (fun x x_1 => x + x_1) Ordinal.omega
-- Ordinal.add_omega_opow
theorem add_omega_opow {a b : Ordinal} (h : a < (omega^b)) : a + (omega^b) = (omega^b) 
Arguments: {a b : Ordinal.{u_1}} (h : a < Ordinal.omega ^ b)
Goal: a + Ordinal.omega ^ b = Ordinal.omega ^ b
-- Ordinal.principal_add_omega_opow
theorem principal_add_omega_opow (o : Ordinal) : Principal (· + ·) (omega^o) 
Arguments: (o : Ordinal.{u_1})
Goal: Ordinal.Principal (fun x x_1 => x + x_1) (Ordinal.omega ^ o)
-- Ordinal.principal_add_iff_zero_or_omega_opow
theorem principal_add_iff_zero_or_omega_opow {o : Ordinal} :
    Principal (· + ·) o ↔ o = 0 ∨ ∃ a : Ordinal, o = (omega^a) 
Arguments: {o : Ordinal.{u_1}}
Goal: Ordinal.Principal (fun x x_1 => x + x_1) o ↔ o = 0 ∨ ∃ a, o = Ordinal.omega ^ a
-- Ordinal.opow_principal_add_of_principal_add
theorem opow_principal_add_of_principal_add {a} (ha : Principal (· + ·) a) (b : Ordinal) :
    Principal (· + ·) (a^b) 
Arguments: {a : Ordinal.{u_1}} (ha : Ordinal.Principal (fun x x_1 => x + x_1) a) (b : Ordinal.{u_1})
Goal: Ordinal.Principal (fun x x_1 => x + x_1) (a ^ b)
-- Ordinal.add_absorp
theorem add_absorp {a b c : Ordinal} (h₁ : a < (omega^b)) (h₂ : (omega^b) ≤ c) : a + c = c 
Arguments: {a b c : Ordinal.{u_1}} (h₁ : a < Ordinal.omega ^ b) (h₂ : Ordinal.omega ^ b ≤ c)
Goal: a + c = c
-- Ordinal.mul_principal_add_is_principal_add
theorem mul_principal_add_is_principal_add (a : Ordinal.{u}) {b : Ordinal.{u}} (hb₁ : b ≠ 1)
    (hb : Principal (· + ·) b) : Principal (· + ·) (a * b) 
Arguments: (a : Ordinal.{u}) {b : Ordinal.{u}} (hb₁ : b ≠ 1) (hb : Ordinal.Principal (fun x x_1 => x + x_1) b)
Goal: Ordinal.Principal (fun x x_1 => x + x_1) (a * b)
-- Ordinal.principal_mul_one
theorem principal_mul_one : Principal (· * ·) 1 
Goal: Ordinal.Principal (fun x x_1 => x * x_1) 1
-- Ordinal.principal_mul_two
theorem principal_mul_two : Principal (· * ·) 2 
Goal: Ordinal.Principal (fun x x_1 => x * x_1) 2
-- Ordinal.principal_mul_of_le_two
theorem principal_mul_of_le_two {o : Ordinal} (ho : o ≤ 2) : Principal (· * ·) o 
Arguments: {o : Ordinal.{u_1}} (ho : o ≤ 2)
Goal: Ordinal.Principal (fun x x_1 => x * x_1) o
-- Ordinal.principal_add_of_principal_mul
theorem principal_add_of_principal_mul {o : Ordinal} (ho : Principal (· * ·) o) (ho₂ : o ≠ 2) :
    Principal (· + ·) o 
Arguments: {o : Ordinal.{u_1}} (ho : Ordinal.Principal (fun x x_1 => x * x_1) o) (ho₂ : o ≠ 2)
Goal: Ordinal.Principal (fun x x_1 => x + x_1) o
-- Ordinal.principal_mul_isLimit
theorem principal_mul_isLimit {o : Ordinal.{u}} (ho₂ : 2 < o) (ho : Principal (· * ·) o) :
    o.IsLimit 
Arguments: {o : Ordinal.{u}} (ho₂ : 2 < o) (ho : Ordinal.Principal (fun x x_1 => x * x_1) o)
Goal: o.IsLimit
-- Ordinal.principal_mul_iff_mul_left_eq
theorem principal_mul_iff_mul_left_eq {o : Ordinal} :
    Principal (· * ·) o ↔ ∀ a, 0 < a → a < o → a * o = o 
Arguments: {o : Ordinal.{u_1}}
Goal: Ordinal.Principal (fun x x_1 => x * x_1) o ↔ ∀ (a : Ordinal.{u_1}), 0 < a → a < o → a * o = o
-- Ordinal.principal_mul_omega
theorem principal_mul_omega : Principal (· * ·) omega 
Goal: Ordinal.Principal (fun x x_1 => x * x_1) Ordinal.omega
-- Ordinal.mul_omega
theorem mul_omega {a : Ordinal} (a0 : 0 < a) (ha : a < omega) : a * omega = omega 
Arguments: {a : Ordinal.{u_1}} (a0 : 0 < a) (ha : a < Ordinal.omega)
Goal: a * Ordinal.omega = Ordinal.omega
-- Ordinal.mul_lt_omega_opow
theorem mul_lt_omega_opow {a b c : Ordinal} (c0 : 0 < c) (ha : a < (omega^c)) (hb : b < omega) :
    a * b < (omega^c) 
Arguments: {a b c : Ordinal.{u_1}} (c0 : 0 < c) (ha : a < Ordinal.omega ^ c) (hb : b < Ordinal.omega)
Goal: a * b < Ordinal.omega ^ c
-- Ordinal.mul_omega_opow_opow
theorem mul_omega_opow_opow {a b : Ordinal} (a0 : 0 < a) (h : a < (omega^omega^b)) :
    a * (omega^omega^b) = (omega^omega^b) 
Arguments: {a b : Ordinal.{u_1}} (a0 : 0 < a) (h : a < Ordinal.omega ^ Ordinal.omega ^ b)
Goal: a * Ordinal.omega ^ Ordinal.omega ^ b = Ordinal.omega ^ Ordinal.omega ^ b
-- Ordinal.principal_mul_omega_opow_opow
theorem principal_mul_omega_opow_opow (o : Ordinal) : Principal (· * ·) (omega^omega^o) 
Arguments: (o : Ordinal.{u_1})
Goal: Ordinal.Principal (fun x x_1 => x * x_1) (Ordinal.omega ^ Ordinal.omega ^ o)
-- Ordinal.principal_add_of_principal_mul_opow
theorem principal_add_of_principal_mul_opow {o b : Ordinal} (hb : 1 < b)
    (ho : Principal (· * ·) (b^o)) : Principal (· + ·) o 
Arguments: {o b : Ordinal.{u_1}} (hb : 1 < b) (ho : Ordinal.Principal (fun x x_1 => x * x_1) (b ^ o))
Goal: Ordinal.Principal (fun x x_1 => x + x_1) o
-- Ordinal.principal_mul_iff_le_two_or_omega_opow_opow
theorem principal_mul_iff_le_two_or_omega_opow_opow {o : Ordinal} :
    Principal (· * ·) o ↔ o ≤ 2 ∨ ∃ a : Ordinal, o = (omega^omega^a) 
Arguments: {o : Ordinal.{u_1}}
Goal: Ordinal.Principal (fun x x_1 => x * x_1) o ↔ o ≤ 2 ∨ ∃ a, o = Ordinal.omega ^ Ordinal.omega ^ a
-- Ordinal.mul_omega_dvd
theorem mul_omega_dvd {a : Ordinal} (a0 : 0 < a) (ha : a < omega) : ∀ {b}, omega ∣ b → a * b = b
  
Arguments: {a : Ordinal.{u_1}} (a0 : 0 < a) (ha : a < Ordinal.omega) {b : Ordinal.{u_1}}
Goal: Ordinal.omega ∣ b → a * b = b
-- Ordinal.mul_eq_opow_log_succ
theorem mul_eq_opow_log_succ {a b : Ordinal.{u}} (ha : a ≠ 0) (hb : Principal (· * ·) b)
    (hb₂ : 2 < b) : a * b = (b^succ (log b a)) 
Arguments: {a b : Ordinal.{u}} (ha : a ≠ 0) (hb : Ordinal.Principal (fun x x_1 => x * x_1) b) (hb₂ : 2 < b)
Goal: a * b = b ^ Order.succ (Ordinal.log b a)
-- Ordinal.principal_opow_omega
theorem principal_opow_omega : Principal (·^·) omega 
Goal: Ordinal.Principal (fun x x_1 => x ^ x_1) Ordinal.omega
-- Ordinal.opow_omega
theorem opow_omega {a : Ordinal} (a1 : 1 < a) (h : a < omega) : (a^omega) = omega 
Arguments: {a : Ordinal.{u_1}} (a1 : 1 < a) (h : a < Ordinal.omega)
Goal: a ^ Ordinal.omega = Ordinal.omega
-- Cardinal.inductionOn
@[elab_as_elim]
theorem inductionOn {p : Cardinal → Prop} (c : Cardinal) (h : ∀ α, p #α) : p c 
Arguments: {p : Cardinal.{u_1} → Prop} (c : Cardinal.{u_1}) (h : ∀ (α : Type u_1), p (Cardinal.mk α))
Goal: p c
-- Cardinal.inductionOn₂
@[elab_as_elim]
theorem inductionOn₂ {p : Cardinal → Cardinal → Prop} (c₁ : Cardinal) (c₂ : Cardinal)
    (h : ∀ α β, p #α #β) : p c₁ c₂ 
Arguments: {p : Cardinal.{u_1} → Cardinal.{u_2} → Prop} (c₁ : Cardinal.{u_1}) (c₂ : Cardinal.{u_2}) (h : ∀ (α : Type u_1) (β : Type u_2), p (Cardinal.mk α) (Cardinal.mk β))
Goal: p c₁ c₂
-- Cardinal.inductionOn₃
@[elab_as_elim]
theorem inductionOn₃ {p : Cardinal → Cardinal → Cardinal → Prop} (c₁ : Cardinal) (c₂ : Cardinal)
    (c₃ : Cardinal) (h : ∀ α β γ, p #α #β #γ) : p c₁ c₂ c₃ 
Arguments: {p : Cardinal.{u_1} → Cardinal.{u_2} → Cardinal.{u_3} → Prop} (c₁ : Cardinal.{u_1}) (c₂ : Cardinal.{u_2}) (c₃ : Cardinal.{u_3}) (h : ∀ (α : Type u_1) (β : Type u_2) (γ : Type u_3), p (Cardinal.mk α) (Cardinal.mk β) (Cardinal.mk γ))
Goal: p c₁ c₂ c₃