set_theory.ordinal.natural_ops | Mathlib porting status

(last sync)

feat(set_theory/ordinal/natural_ops): define natural multiplication (#14324)

Diff

@@ -5,6 +5,7 @@ Authors: Violeta Hernández Palacios
 -/
 
 import set_theory.ordinal.arithmetic
+import tactic.abel
 
 /-!
 # Natural operations on ordinals
@@ -38,7 +39,6 @@ between both types, we attempt to prove and state most results on `ordinal`.
 
 # Todo
 
-- Define natural multiplication and provide a basic API.
 - Prove the characterizations of natural addition and multiplication in terms of the Cantor normal
   form.
 -/
@@ -49,6 +49,8 @@ open function order
 
 noncomputable theory
 
+/-! ### Basic casts between `ordinal` and `nat_ordinal` -/
+
 /-- A type synonym for ordinals with natural addition and multiplication. -/
 @[derive [has_zero, inhabited, has_one, linear_order, succ_order, has_well_founded]]
 def nat_ordinal : Type* := ordinal
@@ -59,10 +61,10 @@ def nat_ordinal : Type* := ordinal
 /-- The identity function between `nat_ordinal` and `ordinal`. -/
 @[pattern] def nat_ordinal.to_ordinal : nat_ordinal ≃o ordinal := order_iso.refl _
 
-open ordinal
-
 namespace nat_ordinal
 
+open ordinal
+
 variables {a b c : nat_ordinal.{u}}
 
 @[simp] theorem to_ordinal_symm_eq : nat_ordinal.to_ordinal.symm = ordinal.to_nat_ordinal := rfl
@@ -95,8 +97,6 @@ end nat_ordinal
 
 namespace ordinal
 
-variables {a b c : ordinal.{u}}
-
 @[simp] theorem to_nat_ordinal_symm_eq : to_nat_ordinal.symm = nat_ordinal.to_ordinal := rfl
 @[simp] theorem to_nat_ordinal_to_ordinal (a : ordinal) : a.to_nat_ordinal.to_ordinal = a := rfl
 
@@ -106,11 +106,14 @@ variables {a b c : ordinal.{u}}
 @[simp] theorem to_nat_ordinal_eq_zero (a) : to_nat_ordinal a = 0 ↔ a = 0 := iff.rfl
 @[simp] theorem to_nat_ordinal_eq_one (a) : to_nat_ordinal a = 1 ↔ a = 1 := iff.rfl
 
-@[simp] theorem to_nat_ordinal_max :
+@[simp] theorem to_nat_ordinal_max (a b : ordinal) :
   to_nat_ordinal (max a b) = max a.to_nat_ordinal b.to_nat_ordinal := rfl
-@[simp] theorem to_nat_ordinal_min :
+@[simp] theorem to_nat_ordinal_min (a b : ordinal) :
   (linear_order.min a b).to_nat_ordinal = linear_order.min a.to_nat_ordinal b.to_nat_ordinal := rfl
 
+/-! We place the definitions of `nadd` and `nmul` before actually developing their API, as this
+guarantees we only need to open the `natural_ops` locale once. -/
+
 /-- Natural addition on ordinals `a ♯ b`, also known as the Hessenberg sum, is recursively defined
 as the least ordinal greater than `a' ♯ b` and `a ♯ b'` for all `a' < a` and `b' < b`. In contrast
 to normal ordinal addition, it is commutative.
@@ -125,6 +128,30 @@ using_well_founded { dec_tac := `[solve_by_elim [psigma.lex.left, psigma.lex.rig
 
 localized "infix (name := ordinal.nadd) ` ♯ `:65 := ordinal.nadd" in natural_ops
 
+/-- Natural multiplication on ordinals `a ⨳ b`, also known as the Hessenberg product, is recursively
+defined as the least ordinal such that `a ⨳ b + a' ⨳ b'` is greater than `a' ⨳ b + a ⨳ b'` for all
+`a' < a` and `b < b'`. In contrast to normal ordinal multiplication, it is commutative and
+distributive (over natural addition).
+
+Natural multiplication can equivalently be characterized as the ordinal resulting from multiplying
+the Cantor normal forms of `a` and `b` as if they were polynomials in `ω`. Addition of exponents is
+done via natural addition. -/
+noncomputable def nmul : ordinal.{u} → ordinal.{u} → ordinal.{u}
+| a b := Inf {c | ∀ (a' < a) (b' < b), nmul a' b ♯ nmul a b' < c ♯ nmul a' b'}
+using_well_founded { dec_tac := `[solve_by_elim [psigma.lex.left, psigma.lex.right]] }
+
+localized "infix ` ⨳ `:70 := ordinal.nmul" in natural_ops
+
+end ordinal
+
+open_locale natural_ops
+
+/-! ### Natural addition -/
+
+namespace ordinal
+
+variables {a b c : ordinal.{u}}
+
 theorem nadd_def (a b : ordinal) : a ♯ b = max
   (blsub.{u u} a $ λ a' h, a' ♯ b)
   (blsub.{u u} b $ λ b' h, a ♯ b') :=
@@ -243,10 +270,10 @@ end
 
 end ordinal
 
-open ordinal
-
 namespace nat_ordinal
 
+open ordinal
+
 instance : has_add nat_ordinal := ⟨nadd⟩
 
 instance add_covariant_class_lt :
@@ -280,21 +307,19 @@ instance : add_monoid_with_one nat_ordinal := add_monoid_with_one.unary
 begin
   induction n with n hn,
   { refl },
-  { change nadd (to_ordinal n) 1 = n + 1,
-    rw hn,
-    apply nadd_one }
+  { change to_ordinal n ♯ 1 = n + 1,
+    rw hn, exact nadd_one n }
 end
 
 end nat_ordinal
 
-open nat_ordinal
-
-open_locale natural_ops
-
 namespace ordinal
 
+theorem nadd_eq_add (a b : ordinal) : a ♯ b = (a.to_nat_ordinal + b.to_nat_ordinal).to_ordinal :=
+rfl
+
 @[simp] theorem to_nat_ordinal_cast_nat (n : ℕ) : to_nat_ordinal n = n :=
-by { rw ←to_ordinal_cast_nat n, refl }
+by { rw ←nat_ordinal.to_ordinal_cast_nat n, refl }
 
 theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c :=
 @lt_of_add_lt_add_left nat_ordinal _ _ _
@@ -314,6 +339,16 @@ theorem nadd_le_nadd_iff_left : ∀ a {b c}, a ♯ b ≤ a ♯ c ↔ b ≤ c :=
 theorem nadd_le_nadd_iff_right : ∀ a {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c :=
 @_root_.add_le_add_iff_right nat_ordinal _ _ _ _
 
+theorem nadd_le_nadd : ∀ {a b c d}, a ≤ b → c ≤ d → a ♯ c ≤ b ♯ d :=
+@add_le_add nat_ordinal _ _ _ _
+theorem nadd_lt_nadd : ∀ {a b c d}, a < b → c < d → a ♯ c < b ♯ d :=
+@add_lt_add nat_ordinal _ _ _ _
+
+theorem nadd_lt_nadd_of_lt_of_le : ∀ {a b c d}, a < b → c ≤ d → a ♯ c < b ♯ d :=
+@add_lt_add_of_lt_of_le nat_ordinal _ _ _ _
+theorem nadd_lt_nadd_of_le_of_lt : ∀ {a b c d}, a ≤ b → c < d → a ♯ c < b ♯ d :=
+@add_lt_add_of_le_of_lt nat_ordinal _ _ _ _
+
 theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c :=
 @_root_.add_left_cancel nat_ordinal _ _
 theorem nadd_right_cancel : ∀ {a b c}, a ♯ b = c ♯ b → a = c :=
@@ -323,4 +358,287 @@ theorem nadd_left_cancel_iff : ∀ {a b c}, a ♯ b = a ♯ c ↔ b = c :=
 theorem nadd_right_cancel_iff : ∀ {a b c}, b ♯ a = c ♯ a ↔ b = c :=
 @add_right_cancel_iff nat_ordinal _ _
 
+theorem le_nadd_self {a b} : a ≤ b ♯ a :=
+by simpa using nadd_le_nadd_right (ordinal.zero_le b) a
+theorem le_nadd_left {a b c} (h : a ≤ c) : a ≤ b ♯ c :=
+le_nadd_self.trans (nadd_le_nadd_left h b)
+theorem le_self_nadd {a b} : a ≤ a ♯ b :=
+by simpa using nadd_le_nadd_left (ordinal.zero_le b) a
+theorem le_nadd_right {a b c} (h : a ≤ b) : a ≤ b ♯ c :=
+le_self_nadd.trans (nadd_le_nadd_right h c)
+
+theorem nadd_left_comm : ∀ a b c, a ♯ (b ♯ c) = b ♯ (a ♯ c) :=
+@add_left_comm nat_ordinal _
+theorem nadd_right_comm : ∀ a b c, a ♯ b ♯ c = a ♯ c ♯ b :=
+@add_right_comm nat_ordinal _
+
+/-! ### Natural multiplication -/
+
+variables {a b c d : ordinal.{u}}
+
+theorem nmul_def (a b : ordinal) :
+  a ⨳ b = Inf {c | ∀ (a' < a) (b' < b), a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'} :=
+by rw nmul
+
+/-- The set in the definition of `nmul` is nonempty. -/
+theorem nmul_nonempty (a b : ordinal.{u}) :
+  {c : ordinal.{u} | ∀ (a' < a) (b' < b), a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}.nonempty :=
+⟨_, λ a' ha b' hb, (lt_blsub₂.{u u u} _ ha hb).trans_le le_self_nadd⟩
+
+theorem nmul_nadd_lt {a' b' : ordinal} (ha : a' < a) (hb : b' < b) :
+  a' ⨳ b ♯ a ⨳ b' < a ⨳ b ♯ a' ⨳ b' :=
+by { rw nmul_def a b, exact Inf_mem (nmul_nonempty a b) a' ha b' hb }
+
+theorem nmul_nadd_le {a' b' : ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
+  a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b' :=
+begin
+  rcases lt_or_eq_of_le ha with ha | rfl,
+  { rcases lt_or_eq_of_le hb with hb | rfl,
+    { exact (nmul_nadd_lt ha hb).le },
+    { rw nadd_comm } },
+  { exact le_rfl }
+end
+
+theorem lt_nmul_iff : c < a ⨳ b ↔ ∃ (a' < a) (b' < b), c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b' :=
+begin
+  refine ⟨λ h, _, _⟩,
+  { rw nmul at h,
+    simpa using not_mem_of_lt_cInf h ⟨0, λ _ _, bot_le⟩ },
+  { rintros ⟨a', ha, b', hb, h⟩,
+    have := h.trans_lt (nmul_nadd_lt ha hb),
+    rwa nadd_lt_nadd_iff_right at this }
+end
+
+theorem nmul_le_iff : a ⨳ b ≤ c ↔ ∀ (a' < a) (b' < b), a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b' :=
+by { rw ←not_iff_not, simp [lt_nmul_iff] }
+
+theorem nmul_comm : ∀ (a b), a ⨳ b = b ⨳ a
+| a b := begin
+  rw [nmul, nmul],
+  congr, ext x, split;
+  intros H c hc d hd,
+  { rw [nadd_comm, ←nmul_comm, ←nmul_comm a, ←nmul_comm d],
+    exact H _ hd _ hc },
+  { rw [nadd_comm, nmul_comm, nmul_comm c, nmul_comm c],
+    exact H _ hd _ hc }
+end
+using_well_founded { dec_tac := `[solve_by_elim [psigma.lex.left, psigma.lex.right]] }
+
+@[simp] theorem nmul_zero (a) : a ⨳ 0 = 0 :=
+by { rw [←ordinal.le_zero, nmul_le_iff], exact λ  _ _ a ha, (ordinal.not_lt_zero a ha).elim }
+
+@[simp] theorem zero_nmul (a) : 0 ⨳ a = 0 :=
+by rw [nmul_comm, nmul_zero]
+
+@[simp] theorem nmul_one : ∀ a, a ⨳ 1 = a
+| a := begin
+  rw nmul,
+  simp only [lt_one_iff_zero, forall_eq, nmul_zero, nadd_zero],
+  convert cInf_Ici,
+  ext b,
+  refine ⟨λ H, le_of_forall_lt (λ c hc, _), λ ha c hc, _⟩,
+  { simpa only [nmul_one] using H c hc },
+  { simpa only [nmul_one] using hc.trans_le ha }
+end
+using_well_founded { dec_tac := `[assumption] }
+
+@[simp] theorem one_nmul (a) : 1 ⨳ a = a :=
+by rw [nmul_comm, nmul_one]
+
+theorem nmul_lt_nmul_of_pos_left (h₁ : a < b) (h₂ : 0 < c) : c ⨳ a < c ⨳ b :=
+lt_nmul_iff.2 ⟨0, h₂, a, h₁, by simp⟩
+
+theorem nmul_lt_nmul_of_pos_right (h₁ : a < b) (h₂ : 0 < c) : a ⨳ c < b ⨳ c :=
+lt_nmul_iff.2 ⟨a, h₁, 0, h₂, by simp⟩
+
+theorem nmul_le_nmul_of_nonneg_left (h₁ : a ≤ b) (h₂ : 0 ≤ c) : c ⨳ a ≤ c ⨳ b :=
+begin
+  rcases lt_or_eq_of_le h₁ with h₁|rfl;
+  rcases lt_or_eq_of_le h₂ with h₂|rfl,
+  { exact (nmul_lt_nmul_of_pos_left h₁ h₂).le },
+  all_goals { simp }
+end
+
+theorem nmul_le_nmul_of_nonneg_right (h₁ : a ≤ b) (h₂ : 0 ≤ c) : a ⨳ c ≤ b ⨳ c :=
+begin
+  rw [nmul_comm, nmul_comm b],
+  exact nmul_le_nmul_of_nonneg_left h₁ h₂
+end
+
+theorem nmul_nadd : ∀ (a b c), a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
+| a b c := begin
+  apply le_antisymm (nmul_le_iff.2 $ λ a' ha d hd, _) (nadd_le_iff.2 ⟨λ d hd, _, λ d hd, _⟩),
+  { rw nmul_nadd,
+    rcases lt_nadd_iff.1 hd with ⟨b', hb, hd⟩ | ⟨c', hc, hd⟩,
+    { have := nadd_lt_nadd_of_lt_of_le (nmul_nadd_lt ha hb) (nmul_nadd_le ha.le hd),
+      rw [nmul_nadd, nmul_nadd] at this,
+      simp only [nadd_assoc] at this,
+      rwa [nadd_left_comm, nadd_left_comm _ (a ⨳ b'), nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left,
+        nadd_left_comm (a' ⨳ b), nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, ←nadd_assoc,
+        ←nadd_assoc] at this },
+    { have := nadd_lt_nadd_of_le_of_lt (nmul_nadd_le ha.le hd) (nmul_nadd_lt ha hc),
+      rw [nmul_nadd, nmul_nadd] at this,
+      simp only [nadd_assoc] at this,
+      rwa [nadd_left_comm, nadd_comm (a ⨳ c), nadd_left_comm (a' ⨳ d), nadd_left_comm (a ⨳ c'),
+        nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, nadd_comm (a' ⨳ c), nadd_left_comm (a ⨳ d),
+        nadd_left_comm (a' ⨳ b), nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, nadd_comm (a ⨳ d),
+        nadd_comm (a' ⨳ d), ←nadd_assoc, ←nadd_assoc] at this } },
+  { rcases lt_nmul_iff.1 hd with ⟨a', ha, b', hb, hd⟩,
+    have := nadd_lt_nadd_of_le_of_lt hd (nmul_nadd_lt ha (nadd_lt_nadd_right hb c)),
+    rw [nmul_nadd, nmul_nadd, nmul_nadd a'] at this,
+    simp only [nadd_assoc] at this,
+    rwa [nadd_left_comm (a' ⨳ b'), nadd_left_comm, nadd_lt_nadd_iff_left, nadd_left_comm,
+      nadd_left_comm _ (a' ⨳ b'), nadd_left_comm (a ⨳ b'), nadd_lt_nadd_iff_left,
+      nadd_left_comm (a' ⨳ c), nadd_left_comm, nadd_lt_nadd_iff_left, nadd_left_comm,
+      nadd_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left] at this },
+  { rcases lt_nmul_iff.1 hd with ⟨a', ha, c', hc, hd⟩,
+    have := nadd_lt_nadd_of_lt_of_le (nmul_nadd_lt ha (nadd_lt_nadd_left hc b)) hd,
+    rw [nmul_nadd, nmul_nadd, nmul_nadd a'] at this,
+    simp only [nadd_assoc] at this,
+    rwa [nadd_left_comm _ (a' ⨳ b), nadd_lt_nadd_iff_left, nadd_left_comm (a' ⨳ c'),
+      nadd_left_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left, nadd_left_comm,
+      nadd_comm (a' ⨳ c'), nadd_left_comm _ (a ⨳ c'), nadd_lt_nadd_iff_left,
+      nadd_comm _ (a' ⨳ c'), nadd_comm _ (a' ⨳ c'), nadd_left_comm,
+      nadd_lt_nadd_iff_left] at this }
+end
+using_well_founded { dec_tac := `[solve_by_elim [psigma.lex.left, psigma.lex.right]] }
+
+theorem nadd_nmul (a b c) : (a ♯ b) ⨳ c = a ⨳ c ♯ b ⨳ c :=
+by rw [nmul_comm, nmul_nadd, nmul_comm, nmul_comm c]
+
+theorem nmul_nadd_lt₃ {a' b' c' : ordinal} (ha : a' < a) (hb : b' < b) (hc : c' < c) :
+  a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' <
+  a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
+by simpa only [nadd_nmul, ←nadd_assoc] using nmul_nadd_lt (nmul_nadd_lt ha hb) hc
+
+theorem nmul_nadd_le₃ {a' b' c' : ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (hc : c' ≤ c) :
+  a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' ≤
+  a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
+by simpa only [nadd_nmul, ←nadd_assoc] using nmul_nadd_le (nmul_nadd_le ha hb) hc
+
+theorem nmul_nadd_lt₃' {a' b' c' : ordinal} (ha : a' < a) (hb : b' < b) (hc : c' < c) :
+  a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
+  a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
+begin
+  simp only [nmul_comm _ (_ ⨳ _)],
+  convert nmul_nadd_lt₃ hb hc ha using 1;
+  { simp only [nadd_eq_add, nat_ordinal.to_ordinal_to_nat_ordinal], abel }
+end
+
+theorem nmul_nadd_le₃' {a' b' c' : ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (hc : c' ≤ c) :
+  a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') ≤
+  a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
+begin
+  simp only [nmul_comm _ (_ ⨳ _)],
+  convert nmul_nadd_le₃ hb hc ha using 1;
+  { simp only [nadd_eq_add, nat_ordinal.to_ordinal_to_nat_ordinal], abel }
+end
+
+theorem lt_nmul_iff₃ : d < a ⨳ b ⨳ c ↔ ∃ (a' < a) (b' < b) (c' < c),
+  d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' ≤
+  a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' :=
+begin
+  refine ⟨λ h, _, _⟩,
+  { rcases lt_nmul_iff.1 h with ⟨e, he, c', hc, H₁⟩,
+    rcases lt_nmul_iff.1 he with ⟨a', ha, b', hb, H₂⟩,
+    refine ⟨a', ha, b', hb, c', hc, _⟩,
+    have := nadd_le_nadd H₁ (nmul_nadd_le H₂ hc.le),
+    simp only [nadd_nmul, nadd_assoc] at this,
+    rw [nadd_left_comm, nadd_left_comm d, nadd_left_comm, nadd_le_nadd_iff_left,
+      nadd_left_comm (a ⨳ b' ⨳ c), nadd_left_comm (a' ⨳ b ⨳ c), nadd_left_comm (a ⨳ b ⨳ c'),
+      nadd_le_nadd_iff_left, nadd_left_comm (a ⨳ b ⨳ c'), nadd_left_comm (a ⨳ b ⨳ c')] at this,
+    simpa only [nadd_assoc] },
+  { rintro ⟨a', ha, b', hb, c', hc, h⟩,
+    have := h.trans_lt (nmul_nadd_lt₃ ha hb hc),
+    repeat { rwa nadd_lt_nadd_iff_right at this } }
+end
+
+theorem nmul_le_iff₃ : a ⨳ b ⨳ c ≤ d ↔ ∀ (a' < a) (b' < b) (c' < c),
+  a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' <
+  d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
+by { rw ←not_iff_not, simp [lt_nmul_iff₃] }
+
+theorem lt_nmul_iff₃' : d < a ⨳ (b ⨳ c) ↔ ∃ (a' < a) (b' < b) (c' < c),
+  d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') ≤
+  a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') :=
+begin
+  simp only [nmul_comm _ (_ ⨳ _), lt_nmul_iff₃, nadd_eq_add, nat_ordinal.to_ordinal_to_nat_ordinal],
+  split; rintro ⟨b', hb, c', hc, a', ha, h⟩,
+  { use [a', ha, b', hb, c', hc], convert h using 1; abel },
+  { use [c', hc, a', ha, b', hb], convert h using 1; abel }
+end
+
+theorem nmul_le_iff₃' : a ⨳ (b ⨳ c) ≤ d ↔ ∀ (a' < a) (b' < b) (c' < c),
+  a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
+  d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
+by { rw ←not_iff_not, simp [lt_nmul_iff₃'] }
+
+theorem nmul_assoc : ∀ a b c, a ⨳ b ⨳ c = a ⨳ (b ⨳ c)
+| a b c := begin
+  apply le_antisymm,
+  { rw nmul_le_iff₃,
+    intros a' ha b' hb c' hc,
+    repeat { rw nmul_assoc },
+    exact nmul_nadd_lt₃' ha hb hc },
+  { rw nmul_le_iff₃',
+    intros a' ha b' hb c' hc,
+    repeat { rw ←nmul_assoc },
+    exact nmul_nadd_lt₃ ha hb hc },
+end
+using_well_founded { dec_tac := `[solve_by_elim [psigma.lex.left, psigma.lex.right]] }
+
+end ordinal
+
+open ordinal
+
+instance : has_mul nat_ordinal := ⟨nmul⟩
+
+instance : ordered_comm_semiring nat_ordinal :=
+{ mul := (*),
+  left_distrib := nmul_nadd,
+  right_distrib := nadd_nmul,
+  zero_mul := zero_nmul,
+  mul_zero := nmul_zero,
+  mul_assoc := nmul_assoc,
+  one := 1,
+  one_mul := one_nmul,
+  mul_one := nmul_one,
+  mul_comm := nmul_comm,
+  zero_le_one := @zero_le_one ordinal _ _ _ _,
+  mul_le_mul_of_nonneg_left := λ a b c, nmul_le_nmul_of_nonneg_left,
+  mul_le_mul_of_nonneg_right := λ a b c, nmul_le_nmul_of_nonneg_right,
+  ..nat_ordinal.ordered_cancel_add_comm_monoid,
+  ..nat_ordinal.linear_order }
+
+namespace ordinal
+
+theorem nmul_eq_mul (a b) : a ⨳ b = (a.to_nat_ordinal * b.to_nat_ordinal).to_ordinal := rfl
+
+theorem nmul_nadd_one : ∀ a b, a ⨳ (b ♯ 1) = a ⨳ b ♯ a := @mul_add_one nat_ordinal _ _ _
+theorem nadd_one_nmul : ∀ a b, (a ♯ 1) ⨳ b = a ⨳ b ♯ b := @add_one_mul nat_ordinal _ _ _
+theorem nmul_succ (a b) : a ⨳ succ b = a ⨳ b ♯ a := by rw [←nadd_one, nmul_nadd_one]
+theorem succ_nmul (a b) : succ a ⨳ b = a ⨳ b ♯ b := by rw [←nadd_one, nadd_one_nmul]
+theorem nmul_add_one : ∀ a b, a ⨳ (b + 1) = a ⨳ b ♯ a := nmul_succ
+theorem add_one_nmul : ∀ a b, (a + 1) ⨳ b = a ⨳ b ♯ b := succ_nmul
+
 end ordinal
+
+namespace nat_ordinal
+
+open ordinal
+
+theorem mul_le_nmul (a b : ordinal.{u}) : a * b ≤ a ⨳ b :=
+begin
+  apply b.limit_rec_on,
+  { simp },
+  { intros c h,
+    rw [mul_succ, nmul_succ],
+    exact (add_le_nadd _ a).trans (nadd_le_nadd_right h a) },
+  { intros c hc H,
+    rcases eq_zero_or_pos a with rfl | ha,
+    { simp },
+    { rw [←is_normal.blsub_eq.{u u} (mul_is_normal ha) hc, blsub_le_iff],
+      exact λ i hi, (H i hi).trans_lt (nmul_lt_nmul_of_pos_left hi ha) } }
+end
+
+end nat_ordinal

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -693,11 +693,11 @@ theorem nmul_nadd_le {a' b' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
 theorem lt_nmul_iff : c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b' :=
   by
   refine' ⟨fun h => _, _⟩
-  · rw [nmul] at h 
+  · rw [nmul] at h
     simpa using not_mem_of_lt_csInf h ⟨0, fun _ _ => bot_le⟩
   · rintro ⟨a', ha, b', hb, h⟩
     have := h.trans_lt (nmul_nadd_lt ha hb)
-    rwa [nadd_lt_nadd_iff_right] at this 
+    rwa [nadd_lt_nadd_iff_right] at this
 #align ordinal.lt_nmul_iff Ordinal.lt_nmul_iff
 -/
 
@@ -791,34 +791,34 @@ theorem nmul_nadd : ∀ a b c, a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
     · rw [nmul_nadd]
       rcases lt_nadd_iff.1 hd with (⟨b', hb, hd⟩ | ⟨c', hc, hd⟩)
       · have := nadd_lt_nadd_of_lt_of_le (nmul_nadd_lt ha hb) (nmul_nadd_le ha.le hd)
-        rw [nmul_nadd, nmul_nadd] at this 
-        simp only [nadd_assoc] at this 
+        rw [nmul_nadd, nmul_nadd] at this
+        simp only [nadd_assoc] at this
         rwa [nadd_left_comm, nadd_left_comm _ (a ⨳ b'), nadd_left_comm (a ⨳ b),
           nadd_lt_nadd_iff_left, nadd_left_comm (a' ⨳ b), nadd_left_comm (a ⨳ b),
-          nadd_lt_nadd_iff_left, ← nadd_assoc, ← nadd_assoc] at this 
+          nadd_lt_nadd_iff_left, ← nadd_assoc, ← nadd_assoc] at this
       · have := nadd_lt_nadd_of_le_of_lt (nmul_nadd_le ha.le hd) (nmul_nadd_lt ha hc)
-        rw [nmul_nadd, nmul_nadd] at this 
-        simp only [nadd_assoc] at this 
+        rw [nmul_nadd, nmul_nadd] at this
+        simp only [nadd_assoc] at this
         rwa [nadd_left_comm, nadd_comm (a ⨳ c), nadd_left_comm (a' ⨳ d), nadd_left_comm (a ⨳ c'),
           nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, nadd_comm (a' ⨳ c), nadd_left_comm (a ⨳ d),
           nadd_left_comm (a' ⨳ b), nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, nadd_comm (a ⨳ d),
-          nadd_comm (a' ⨳ d), ← nadd_assoc, ← nadd_assoc] at this 
+          nadd_comm (a' ⨳ d), ← nadd_assoc, ← nadd_assoc] at this
     · rcases lt_nmul_iff.1 hd with ⟨a', ha, b', hb, hd⟩
       have := nadd_lt_nadd_of_le_of_lt hd (nmul_nadd_lt ha (nadd_lt_nadd_right hb c))
-      rw [nmul_nadd, nmul_nadd, nmul_nadd a'] at this 
-      simp only [nadd_assoc] at this 
+      rw [nmul_nadd, nmul_nadd, nmul_nadd a'] at this
+      simp only [nadd_assoc] at this
       rwa [nadd_left_comm (a' ⨳ b'), nadd_left_comm, nadd_lt_nadd_iff_left, nadd_left_comm,
         nadd_left_comm _ (a' ⨳ b'), nadd_left_comm (a ⨳ b'), nadd_lt_nadd_iff_left,
         nadd_left_comm (a' ⨳ c), nadd_left_comm, nadd_lt_nadd_iff_left, nadd_left_comm,
-        nadd_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left] at this 
+        nadd_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left] at this
     · rcases lt_nmul_iff.1 hd with ⟨a', ha, c', hc, hd⟩
       have := nadd_lt_nadd_of_lt_of_le (nmul_nadd_lt ha (nadd_lt_nadd_left hc b)) hd
-      rw [nmul_nadd, nmul_nadd, nmul_nadd a'] at this 
-      simp only [nadd_assoc] at this 
+      rw [nmul_nadd, nmul_nadd, nmul_nadd a'] at this
+      simp only [nadd_assoc] at this
       rwa [nadd_left_comm _ (a' ⨳ b), nadd_lt_nadd_iff_left, nadd_left_comm (a' ⨳ c'),
         nadd_left_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left, nadd_left_comm, nadd_comm (a' ⨳ c'),
         nadd_left_comm _ (a ⨳ c'), nadd_lt_nadd_iff_left, nadd_comm _ (a' ⨳ c'),
-        nadd_comm _ (a' ⨳ c'), nadd_left_comm, nadd_lt_nadd_iff_left] at this 
+        nadd_comm _ (a' ⨳ c'), nadd_left_comm, nadd_lt_nadd_iff_left] at this
 decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nmul_nadd Ordinal.nmul_nadd
 -/
@@ -881,14 +881,14 @@ theorem lt_nmul_iff₃ :
     rcases lt_nmul_iff.1 he with ⟨a', ha, b', hb, H₂⟩
     refine' ⟨a', ha, b', hb, c', hc, _⟩
     have := nadd_le_nadd H₁ (nmul_nadd_le H₂ hc.le)
-    simp only [nadd_nmul, nadd_assoc] at this 
+    simp only [nadd_nmul, nadd_assoc] at this
     rw [nadd_left_comm, nadd_left_comm d, nadd_left_comm, nadd_le_nadd_iff_left,
       nadd_left_comm (a ⨳ b' ⨳ c), nadd_left_comm (a' ⨳ b ⨳ c), nadd_left_comm (a ⨳ b ⨳ c'),
-      nadd_le_nadd_iff_left, nadd_left_comm (a ⨳ b ⨳ c'), nadd_left_comm (a ⨳ b ⨳ c')] at this 
+      nadd_le_nadd_iff_left, nadd_left_comm (a ⨳ b ⨳ c'), nadd_left_comm (a ⨳ b ⨳ c')] at this
     simpa only [nadd_assoc]
   · rintro ⟨a', ha, b', hb, c', hc, h⟩
     have := h.trans_lt (nmul_nadd_lt₃ ha hb hc)
-    repeat' rwa [nadd_lt_nadd_iff_right] at this 
+    repeat' rwa [nadd_lt_nadd_iff_right] at this
 #align ordinal.lt_nmul_iff₃ Ordinal.lt_nmul_iff₃
 -/

bump to nightly-2023-12-06-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

d09917f6

Diff

@@ -468,7 +468,7 @@ instance add_covariantClass_le : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (
 #print NatOrdinal.add_contravariantClass_le /-
 instance add_contravariantClass_le :
     ContravariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
-  ⟨fun a b c h => by by_contra' h'; exact h.not_lt (add_lt_add_left h' a)⟩
+  ⟨fun a b c h => by by_contra! h'; exact h.not_lt (add_lt_add_left h' a)⟩
 #align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_le
 -/

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Violeta Hernández Palacios. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
 -/
-import Mathbin.SetTheory.Ordinal.Arithmetic
-import Mathbin.Tactic.Abel
+import SetTheory.Ordinal.Arithmetic
+import Tactic.Abel
 
 #align_import set_theory.ordinal.natural_ops from "leanprover-community/mathlib"@"31b269b60935483943542d547a6dd83a66b37dc7"

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Violeta Hernández Palacios. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
-
-! This file was ported from Lean 3 source module set_theory.ordinal.natural_ops
-! leanprover-community/mathlib commit 31b269b60935483943542d547a6dd83a66b37dc7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.SetTheory.Ordinal.Arithmetic
 import Mathbin.Tactic.Abel
 
+#align_import set_theory.ordinal.natural_ops from "leanprover-community/mathlib"@"31b269b60935483943542d547a6dd83a66b37dc7"
+
 /-!
 # Natural operations on ordinals

bump to nightly-2023-07-18-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/bf2428c9486c407ca38b5b3fb10b87dad0bc99fa

a4aa5276

Diff

@@ -256,6 +256,7 @@ decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 
 scoped[NaturalOps] infixl:65 " ♯ " => Ordinal.nadd
 
+#print Ordinal.nmul /-
 /-- Natural multiplication on ordinals `a ⨳ b`, also known as the Hessenberg product, is recursively
 defined as the least ordinal such that `a ⨳ b + a' ⨳ b'` is greater than `a' ⨳ b + a ⨳ b'` for all
 `a' < a` and `b < b'`. In contrast to normal ordinal multiplication, it is commutative and
@@ -268,6 +269,7 @@ noncomputable def nmul : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
   | a, b => sInf {c | ∀ a' < a, ∀ b' < b, nmul a' b ♯ nmul a b' < c ♯ nmul a' b'}
 decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nmul Ordinal.nmul
+-/
 
 scoped[NaturalOps] infixl:70 " ⨳ " => Ordinal.nmul
 
@@ -509,9 +511,11 @@ end NatOrdinal
 
 namespace Ordinal
 
+#print Ordinal.nadd_eq_add /-
 theorem nadd_eq_add (a b : Ordinal) : a ♯ b = (a.toNatOrdinal + b.toNatOrdinal).toOrdinal :=
   rfl
 #align ordinal.nadd_eq_add Ordinal.nadd_eq_add
+-/
 
 #print Ordinal.toNatOrdinal_cast_nat /-
 @[simp]
@@ -568,21 +572,29 @@ theorem nadd_le_nadd_iff_right : ∀ (a) {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c
 #align ordinal.nadd_le_nadd_iff_right Ordinal.nadd_le_nadd_iff_right
 -/
 
+#print Ordinal.nadd_le_nadd /-
 theorem nadd_le_nadd : ∀ {a b c d}, a ≤ b → c ≤ d → a ♯ c ≤ b ♯ d :=
   @add_le_add NatOrdinal _ _ _ _
 #align ordinal.nadd_le_nadd Ordinal.nadd_le_nadd
+-/
 
+#print Ordinal.nadd_lt_nadd /-
 theorem nadd_lt_nadd : ∀ {a b c d}, a < b → c < d → a ♯ c < b ♯ d :=
   @add_lt_add NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd Ordinal.nadd_lt_nadd
+-/
 
+#print Ordinal.nadd_lt_nadd_of_lt_of_le /-
 theorem nadd_lt_nadd_of_lt_of_le : ∀ {a b c d}, a < b → c ≤ d → a ♯ c < b ♯ d :=
   @add_lt_add_of_lt_of_le NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd_of_lt_of_le Ordinal.nadd_lt_nadd_of_lt_of_le
+-/
 
+#print Ordinal.nadd_lt_nadd_of_le_of_lt /-
 theorem nadd_lt_nadd_of_le_of_lt : ∀ {a b c d}, a ≤ b → c < d → a ♯ c < b ♯ d :=
   @add_lt_add_of_le_of_lt NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd_of_le_of_lt Ordinal.nadd_lt_nadd_of_le_of_lt
+-/
 
 #print Ordinal.nadd_left_cancel /-
 theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c :=
@@ -608,48 +620,67 @@ theorem nadd_right_cancel_iff : ∀ {a b c}, b ♯ a = c ♯ a ↔ b = c :=
 #align ordinal.nadd_right_cancel_iff Ordinal.nadd_right_cancel_iff
 -/
 
+#print Ordinal.le_nadd_self /-
 theorem le_nadd_self {a b} : a ≤ b ♯ a := by simpa using nadd_le_nadd_right (Ordinal.zero_le b) a
 #align ordinal.le_nadd_self Ordinal.le_nadd_self
+-/
 
+#print Ordinal.le_nadd_left /-
 theorem le_nadd_left {a b c} (h : a ≤ c) : a ≤ b ♯ c :=
   le_nadd_self.trans (nadd_le_nadd_left h b)
 #align ordinal.le_nadd_left Ordinal.le_nadd_left
+-/
 
+#print Ordinal.le_self_nadd /-
 theorem le_self_nadd {a b} : a ≤ a ♯ b := by simpa using nadd_le_nadd_left (Ordinal.zero_le b) a
 #align ordinal.le_self_nadd Ordinal.le_self_nadd
+-/
 
+#print Ordinal.le_nadd_right /-
 theorem le_nadd_right {a b c} (h : a ≤ b) : a ≤ b ♯ c :=
   le_self_nadd.trans (nadd_le_nadd_right h c)
 #align ordinal.le_nadd_right Ordinal.le_nadd_right
+-/
 
+#print Ordinal.nadd_left_comm /-
 theorem nadd_left_comm : ∀ a b c, a ♯ (b ♯ c) = b ♯ (a ♯ c) :=
   @add_left_comm NatOrdinal _
 #align ordinal.nadd_left_comm Ordinal.nadd_left_comm
+-/
 
+#print Ordinal.nadd_right_comm /-
 theorem nadd_right_comm : ∀ a b c, a ♯ b ♯ c = a ♯ c ♯ b :=
   @add_right_comm NatOrdinal _
 #align ordinal.nadd_right_comm Ordinal.nadd_right_comm
+-/
 
 /-! ### Natural multiplication -/
 
 
 variable {a b c d : Ordinal.{u}}
 
+#print Ordinal.nmul_def /-
 theorem nmul_def (a b : Ordinal) :
     a ⨳ b = sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'} := by rw [nmul]
 #align ordinal.nmul_def Ordinal.nmul_def
+-/
 
+#print Ordinal.nmul_nonempty /-
 /-- The set in the definition of `nmul` is nonempty. -/
 theorem nmul_nonempty (a b : Ordinal.{u}) :
     {c : Ordinal.{u} | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}.Nonempty :=
   ⟨_, fun a' ha b' hb => (lt_blsub₂.{u, u, u} _ ha hb).trans_le le_self_nadd⟩
 #align ordinal.nmul_nonempty Ordinal.nmul_nonempty
+-/
 
+#print Ordinal.nmul_nadd_lt /-
 theorem nmul_nadd_lt {a' b' : Ordinal} (ha : a' < a) (hb : b' < b) :
     a' ⨳ b ♯ a ⨳ b' < a ⨳ b ♯ a' ⨳ b' := by rw [nmul_def a b];
   exact csInf_mem (nmul_nonempty a b) a' ha b' hb
 #align ordinal.nmul_nadd_lt Ordinal.nmul_nadd_lt
+-/
 
+#print Ordinal.nmul_nadd_le /-
 theorem nmul_nadd_le {a' b' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
     a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b' :=
   by
@@ -659,7 +690,9 @@ theorem nmul_nadd_le {a' b' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
     · rw [nadd_comm]
   · exact le_rfl
 #align ordinal.nmul_nadd_le Ordinal.nmul_nadd_le
+-/
 
+#print Ordinal.lt_nmul_iff /-
 theorem lt_nmul_iff : c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b' :=
   by
   refine' ⟨fun h => _, _⟩
@@ -669,11 +702,15 @@ theorem lt_nmul_iff : c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' 
     have := h.trans_lt (nmul_nadd_lt ha hb)
     rwa [nadd_lt_nadd_iff_right] at this 
 #align ordinal.lt_nmul_iff Ordinal.lt_nmul_iff
+-/
 
+#print Ordinal.nmul_le_iff /-
 theorem nmul_le_iff : a ⨳ b ≤ c ↔ ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b' := by
   rw [← not_iff_not]; simp [lt_nmul_iff]
 #align ordinal.nmul_le_iff Ordinal.nmul_le_iff
+-/
 
+#print Ordinal.nmul_comm /-
 theorem nmul_comm : ∀ a b, a ⨳ b = b ⨳ a
   | a, b => by
     rw [nmul, nmul]
@@ -684,16 +721,22 @@ theorem nmul_comm : ∀ a b, a ⨳ b = b ⨳ a
       exact H _ hd _ hc
 decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nmul_comm Ordinal.nmul_comm
+-/
 
+#print Ordinal.nmul_zero /-
 @[simp]
 theorem nmul_zero (a) : a ⨳ 0 = 0 := by rw [← Ordinal.le_zero, nmul_le_iff];
   exact fun _ _ a ha => (Ordinal.not_lt_zero a ha).elim
 #align ordinal.nmul_zero Ordinal.nmul_zero
+-/
 
+#print Ordinal.zero_nmul /-
 @[simp]
 theorem zero_nmul (a) : 0 ⨳ a = 0 := by rw [nmul_comm, nmul_zero]
 #align ordinal.zero_nmul Ordinal.zero_nmul
+-/
 
+#print Ordinal.nmul_one /-
 @[simp]
 theorem nmul_one : ∀ a, a ⨳ 1 = a
   | a => by
@@ -705,32 +748,44 @@ theorem nmul_one : ∀ a, a ⨳ 1 = a
     · simpa only [nmul_one] using H c hc
     · simpa only [nmul_one] using hc.trans_le ha
 #align ordinal.nmul_one Ordinal.nmul_one
+-/
 
+#print Ordinal.one_nmul /-
 @[simp]
 theorem one_nmul (a) : 1 ⨳ a = a := by rw [nmul_comm, nmul_one]
 #align ordinal.one_nmul Ordinal.one_nmul
+-/
 
+#print Ordinal.nmul_lt_nmul_of_pos_left /-
 theorem nmul_lt_nmul_of_pos_left (h₁ : a < b) (h₂ : 0 < c) : c ⨳ a < c ⨳ b :=
   lt_nmul_iff.2 ⟨0, h₂, a, h₁, by simp⟩
 #align ordinal.nmul_lt_nmul_of_pos_left Ordinal.nmul_lt_nmul_of_pos_left
+-/
 
+#print Ordinal.nmul_lt_nmul_of_pos_right /-
 theorem nmul_lt_nmul_of_pos_right (h₁ : a < b) (h₂ : 0 < c) : a ⨳ c < b ⨳ c :=
   lt_nmul_iff.2 ⟨a, h₁, 0, h₂, by simp⟩
 #align ordinal.nmul_lt_nmul_of_pos_right Ordinal.nmul_lt_nmul_of_pos_right
+-/
 
+#print Ordinal.nmul_le_nmul_of_nonneg_left /-
 theorem nmul_le_nmul_of_nonneg_left (h₁ : a ≤ b) (h₂ : 0 ≤ c) : c ⨳ a ≤ c ⨳ b :=
   by
   rcases lt_or_eq_of_le h₁ with (h₁ | rfl) <;> rcases lt_or_eq_of_le h₂ with (h₂ | rfl)
   · exact (nmul_lt_nmul_of_pos_left h₁ h₂).le
   all_goals simp
 #align ordinal.nmul_le_nmul_of_nonneg_left Ordinal.nmul_le_nmul_of_nonneg_left
+-/
 
+#print Ordinal.nmul_le_nmul_of_nonneg_right /-
 theorem nmul_le_nmul_of_nonneg_right (h₁ : a ≤ b) (h₂ : 0 ≤ c) : a ⨳ c ≤ b ⨳ c :=
   by
   rw [nmul_comm, nmul_comm b]
   exact nmul_le_nmul_of_nonneg_left h₁ h₂
 #align ordinal.nmul_le_nmul_of_nonneg_right Ordinal.nmul_le_nmul_of_nonneg_right
+-/
 
+#print Ordinal.nmul_nadd /-
 theorem nmul_nadd : ∀ a b c, a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
   | a, b, c =>
     by
@@ -769,23 +824,31 @@ theorem nmul_nadd : ∀ a b c, a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
         nadd_comm _ (a' ⨳ c'), nadd_left_comm, nadd_lt_nadd_iff_left] at this 
 decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nmul_nadd Ordinal.nmul_nadd
+-/
 
+#print Ordinal.nadd_nmul /-
 theorem nadd_nmul (a b c) : (a ♯ b) ⨳ c = a ⨳ c ♯ b ⨳ c := by
   rw [nmul_comm, nmul_nadd, nmul_comm, nmul_comm c]
 #align ordinal.nadd_nmul Ordinal.nadd_nmul
+-/
 
+#print Ordinal.nmul_nadd_lt₃ /-
 theorem nmul_nadd_lt₃ {a' b' c' : Ordinal} (ha : a' < a) (hb : b' < b) (hc : c' < c) :
     a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' <
       a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
   by simpa only [nadd_nmul, ← nadd_assoc] using nmul_nadd_lt (nmul_nadd_lt ha hb) hc
 #align ordinal.nmul_nadd_lt₃ Ordinal.nmul_nadd_lt₃
+-/
 
+#print Ordinal.nmul_nadd_le₃ /-
 theorem nmul_nadd_le₃ {a' b' c' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (hc : c' ≤ c) :
     a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' ≤
       a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
   by simpa only [nadd_nmul, ← nadd_assoc] using nmul_nadd_le (nmul_nadd_le ha hb) hc
 #align ordinal.nmul_nadd_le₃ Ordinal.nmul_nadd_le₃
+-/
 
+#print Ordinal.nmul_nadd_lt₃' /-
 theorem nmul_nadd_lt₃' {a' b' c' : Ordinal} (ha : a' < a) (hb : b' < b) (hc : c' < c) :
     a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
       a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
@@ -794,7 +857,9 @@ theorem nmul_nadd_lt₃' {a' b' c' : Ordinal} (ha : a' < a) (hb : b' < b) (hc :
   convert nmul_nadd_lt₃ hb hc ha using 1 <;>
     · simp only [nadd_eq_add, NatOrdinal.toOrdinal_toNatOrdinal]; abel
 #align ordinal.nmul_nadd_lt₃' Ordinal.nmul_nadd_lt₃'
+-/
 
+#print Ordinal.nmul_nadd_le₃' /-
 theorem nmul_nadd_le₃' {a' b' c' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (hc : c' ≤ c) :
     a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') ≤
       a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
@@ -803,7 +868,9 @@ theorem nmul_nadd_le₃' {a' b' c' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (h
   convert nmul_nadd_le₃ hb hc ha using 1 <;>
     · simp only [nadd_eq_add, NatOrdinal.toOrdinal_toNatOrdinal]; abel
 #align ordinal.nmul_nadd_le₃' Ordinal.nmul_nadd_le₃'
+-/
 
+#print Ordinal.lt_nmul_iff₃ /-
 theorem lt_nmul_iff₃ :
     d < a ⨳ b ⨳ c ↔
       ∃ a' < a,
@@ -826,7 +893,9 @@ theorem lt_nmul_iff₃ :
     have := h.trans_lt (nmul_nadd_lt₃ ha hb hc)
     repeat' rwa [nadd_lt_nadd_iff_right] at this 
 #align ordinal.lt_nmul_iff₃ Ordinal.lt_nmul_iff₃
+-/
 
+#print Ordinal.nmul_le_iff₃ /-
 theorem nmul_le_iff₃ :
     a ⨳ b ⨳ c ≤ d ↔
       ∀ a' < a,
@@ -836,7 +905,9 @@ theorem nmul_le_iff₃ :
               d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
   by rw [← not_iff_not]; simp [lt_nmul_iff₃]
 #align ordinal.nmul_le_iff₃ Ordinal.nmul_le_iff₃
+-/
 
+#print Ordinal.lt_nmul_iff₃' /-
 theorem lt_nmul_iff₃' :
     d < a ⨳ (b ⨳ c) ↔
       ∃ a' < a,
@@ -850,7 +921,9 @@ theorem lt_nmul_iff₃' :
   · use a', ha, b', hb, c', hc; convert h using 1 <;> abel
   · use c', hc, a', ha, b', hb; convert h using 1 <;> abel
 #align ordinal.lt_nmul_iff₃' Ordinal.lt_nmul_iff₃'
+-/
 
+#print Ordinal.nmul_le_iff₃' /-
 theorem nmul_le_iff₃' :
     a ⨳ (b ⨳ c) ≤ d ↔
       ∀ a' < a,
@@ -860,7 +933,9 @@ theorem nmul_le_iff₃' :
               d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
   by rw [← not_iff_not]; simp [lt_nmul_iff₃']
 #align ordinal.nmul_le_iff₃' Ordinal.nmul_le_iff₃'
+-/
 
+#print Ordinal.nmul_assoc /-
 theorem nmul_assoc : ∀ a b c, a ⨳ b ⨳ c = a ⨳ (b ⨳ c)
   | a, b, c => by
     apply le_antisymm
@@ -874,6 +949,7 @@ theorem nmul_assoc : ∀ a b c, a ⨳ b ⨳ c = a ⨳ (b ⨳ c)
       exact nmul_nadd_lt₃ ha hb hc
 decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nmul_assoc Ordinal.nmul_assoc
+-/
 
 end Ordinal
 
@@ -901,31 +977,45 @@ instance : OrderedCommSemiring NatOrdinal :=
 
 namespace Ordinal
 
+#print Ordinal.nmul_eq_mul /-
 theorem nmul_eq_mul (a b) : a ⨳ b = (a.toNatOrdinal * b.toNatOrdinal).toOrdinal :=
   rfl
 #align ordinal.nmul_eq_mul Ordinal.nmul_eq_mul
+-/
 
+#print Ordinal.nmul_nadd_one /-
 theorem nmul_nadd_one : ∀ a b, a ⨳ (b ♯ 1) = a ⨳ b ♯ a :=
   @mul_add_one NatOrdinal _ _ _
 #align ordinal.nmul_nadd_one Ordinal.nmul_nadd_one
+-/
 
+#print Ordinal.nadd_one_nmul /-
 theorem nadd_one_nmul : ∀ a b, (a ♯ 1) ⨳ b = a ⨳ b ♯ b :=
   @add_one_mul NatOrdinal _ _ _
 #align ordinal.nadd_one_nmul Ordinal.nadd_one_nmul
+-/
 
+#print Ordinal.nmul_succ /-
 theorem nmul_succ (a b) : a ⨳ succ b = a ⨳ b ♯ a := by rw [← nadd_one, nmul_nadd_one]
 #align ordinal.nmul_succ Ordinal.nmul_succ
+-/
 
+#print Ordinal.succ_nmul /-
 theorem succ_nmul (a b) : succ a ⨳ b = a ⨳ b ♯ b := by rw [← nadd_one, nadd_one_nmul]
 #align ordinal.succ_nmul Ordinal.succ_nmul
+-/
 
+#print Ordinal.nmul_add_one /-
 theorem nmul_add_one : ∀ a b, a ⨳ (b + 1) = a ⨳ b ♯ a :=
   nmul_succ
 #align ordinal.nmul_add_one Ordinal.nmul_add_one
+-/
 
+#print Ordinal.add_one_nmul /-
 theorem add_one_nmul : ∀ a b, (a + 1) ⨳ b = a ⨳ b ♯ b :=
   succ_nmul
 #align ordinal.add_one_nmul Ordinal.add_one_nmul
+-/
 
 end Ordinal
 
@@ -933,6 +1023,7 @@ namespace NatOrdinal
 
 open Ordinal
 
+#print NatOrdinal.mul_le_nmul /-
 theorem mul_le_nmul (a b : Ordinal.{u}) : a * b ≤ a ⨳ b :=
   by
   apply b.limit_rec_on
@@ -946,6 +1037,7 @@ theorem mul_le_nmul (a b : Ordinal.{u}) : a * b ≤ a ⨳ b :=
     · rw [← IsNormal.blsub_eq.{u, u} (mul_is_normal ha) hc, blsub_le_iff]
       exact fun i hi => (H i hi).trans_lt (nmul_lt_nmul_of_pos_left hi ha)
 #align nat_ordinal.mul_le_nmul NatOrdinal.mul_le_nmul
+-/
 
 end NatOrdinal

bump to nightly-2023-07-17-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/bf2428c9486c407ca38b5b3fb10b87dad0bc99fa

a159b65f

Diff

@@ -4,11 +4,12 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
 
 ! This file was ported from Lean 3 source module set_theory.ordinal.natural_ops
-! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
+! leanprover-community/mathlib commit 31b269b60935483943542d547a6dd83a66b37dc7
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
 import Mathbin.SetTheory.Ordinal.Arithmetic
+import Mathbin.Tactic.Abel
 
 /-!
 # Natural operations on ordinals
@@ -42,7 +43,6 @@ between both types, we attempt to prove and state most results on `ordinal`.
 
 # Todo
 
-- Define natural multiplication and provide a basic API.
 - Prove the characterizations of natural addition and multiplication in terms of the Cantor normal
   form.
 -/
@@ -54,6 +54,9 @@ open Function Order
 
 noncomputable section
 
+/-! ### Basic casts between `ordinal` and `nat_ordinal` -/
+
+
 #print NatOrdinal /-
 /-- A type synonym for ordinals with natural addition and multiplication. -/
 def NatOrdinal : Type _ :=
@@ -78,10 +81,10 @@ def NatOrdinal.toOrdinal : NatOrdinal ≃o Ordinal :=
 #align nat_ordinal.to_ordinal NatOrdinal.toOrdinal
 -/
 
-open Ordinal
-
 namespace NatOrdinal
 
+open Ordinal
+
 variable {a b c : NatOrdinal.{u}}
 
 #print NatOrdinal.toOrdinal_symm_eq /-
@@ -176,8 +179,6 @@ end NatOrdinal
 
 namespace Ordinal
 
-variable {a b c : Ordinal.{u}}
-
 #print Ordinal.toNatOrdinal_symm_eq /-
 @[simp]
 theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal :=
@@ -222,19 +223,24 @@ theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
 
 #print Ordinal.toNatOrdinal_max /-
 @[simp]
-theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOrdinal :=
+theorem toNatOrdinal_max (a b : Ordinal) :
+    toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOrdinal :=
   rfl
 #align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_max
 -/
 
 #print Ordinal.toNatOrdinal_min /-
 @[simp]
-theorem toNatOrdinal_min :
+theorem toNatOrdinal_min (a b : Ordinal) :
     (LinearOrder.min a b).toNatOrdinal = LinearOrder.min a.toNatOrdinal b.toNatOrdinal :=
   rfl
 #align ordinal.to_nat_ordinal_min Ordinal.toNatOrdinal_min
 -/
 
+/-! We place the definitions of `nadd` and `nmul` before actually developing their API, as this
+guarantees we only need to open the `natural_ops` locale once. -/
+
+
 #print Ordinal.nadd /-
 /-- Natural addition on ordinals `a ♯ b`, also known as the Hessenberg sum, is recursively defined
 as the least ordinal greater than `a' ♯ b` and `a ♯ b'` for all `a' < a` and `b' < b`. In contrast
@@ -250,6 +256,32 @@ decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 
 scoped[NaturalOps] infixl:65 " ♯ " => Ordinal.nadd
 
+/-- Natural multiplication on ordinals `a ⨳ b`, also known as the Hessenberg product, is recursively
+defined as the least ordinal such that `a ⨳ b + a' ⨳ b'` is greater than `a' ⨳ b + a ⨳ b'` for all
+`a' < a` and `b < b'`. In contrast to normal ordinal multiplication, it is commutative and
+distributive (over natural addition).
+
+Natural multiplication can equivalently be characterized as the ordinal resulting from multiplying
+the Cantor normal forms of `a` and `b` as if they were polynomials in `ω`. Addition of exponents is
+done via natural addition. -/
+noncomputable def nmul : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
+  | a, b => sInf {c | ∀ a' < a, ∀ b' < b, nmul a' b ♯ nmul a b' < c ♯ nmul a' b'}
+decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+#align ordinal.nmul Ordinal.nmul
+
+scoped[NaturalOps] infixl:70 " ⨳ " => Ordinal.nmul
+
+end Ordinal
+
+open scoped NaturalOps
+
+/-! ### Natural addition -/
+
+
+namespace Ordinal
+
+variable {a b c : Ordinal.{u}}
+
 #print Ordinal.nadd_def /-
 theorem nadd_def (a b : Ordinal) :
     a ♯ b = max (blsub.{u, u} a fun a' h => a' ♯ b) (blsub.{u, u} b fun b' h => a ♯ b') := by
@@ -415,10 +447,10 @@ theorem add_le_nadd : a + b ≤ a ♯ b := by
 
 end Ordinal
 
-open Ordinal
-
 namespace NatOrdinal
 
+open Ordinal
+
 instance : Add NatOrdinal :=
   ⟨nadd⟩
 
@@ -468,23 +500,23 @@ theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n :=
   by
   induction' n with n hn
   · rfl
-  · change nadd (to_ordinal n) 1 = n + 1
-    rw [hn]
-    apply nadd_one
+  · change to_ordinal n ♯ 1 = n + 1
+    rw [hn]; exact nadd_one n
 #align nat_ordinal.to_ordinal_cast_nat NatOrdinal.toOrdinal_cast_nat
 -/
 
 end NatOrdinal
 
-open NatOrdinal
-
-open scoped NaturalOps
-
 namespace Ordinal
 
+theorem nadd_eq_add (a b : Ordinal) : a ♯ b = (a.toNatOrdinal + b.toNatOrdinal).toOrdinal :=
+  rfl
+#align ordinal.nadd_eq_add Ordinal.nadd_eq_add
+
 #print Ordinal.toNatOrdinal_cast_nat /-
 @[simp]
-theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n := by rw [← to_ordinal_cast_nat n]; rfl
+theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n := by
+  rw [← NatOrdinal.toOrdinal_cast_nat n]; rfl
 #align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_nat
 -/
 
@@ -536,6 +568,22 @@ theorem nadd_le_nadd_iff_right : ∀ (a) {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c
 #align ordinal.nadd_le_nadd_iff_right Ordinal.nadd_le_nadd_iff_right
 -/
 
+theorem nadd_le_nadd : ∀ {a b c d}, a ≤ b → c ≤ d → a ♯ c ≤ b ♯ d :=
+  @add_le_add NatOrdinal _ _ _ _
+#align ordinal.nadd_le_nadd Ordinal.nadd_le_nadd
+
+theorem nadd_lt_nadd : ∀ {a b c d}, a < b → c < d → a ♯ c < b ♯ d :=
+  @add_lt_add NatOrdinal _ _ _ _
+#align ordinal.nadd_lt_nadd Ordinal.nadd_lt_nadd
+
+theorem nadd_lt_nadd_of_lt_of_le : ∀ {a b c d}, a < b → c ≤ d → a ♯ c < b ♯ d :=
+  @add_lt_add_of_lt_of_le NatOrdinal _ _ _ _
+#align ordinal.nadd_lt_nadd_of_lt_of_le Ordinal.nadd_lt_nadd_of_lt_of_le
+
+theorem nadd_lt_nadd_of_le_of_lt : ∀ {a b c d}, a ≤ b → c < d → a ♯ c < b ♯ d :=
+  @add_lt_add_of_le_of_lt NatOrdinal _ _ _ _
+#align ordinal.nadd_lt_nadd_of_le_of_lt Ordinal.nadd_lt_nadd_of_le_of_lt
+
 #print Ordinal.nadd_left_cancel /-
 theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c :=
   @add_left_cancel NatOrdinal _ _
@@ -560,5 +608,344 @@ theorem nadd_right_cancel_iff : ∀ {a b c}, b ♯ a = c ♯ a ↔ b = c :=
 #align ordinal.nadd_right_cancel_iff Ordinal.nadd_right_cancel_iff
 -/
 
+theorem le_nadd_self {a b} : a ≤ b ♯ a := by simpa using nadd_le_nadd_right (Ordinal.zero_le b) a
+#align ordinal.le_nadd_self Ordinal.le_nadd_self
+
+theorem le_nadd_left {a b c} (h : a ≤ c) : a ≤ b ♯ c :=
+  le_nadd_self.trans (nadd_le_nadd_left h b)
+#align ordinal.le_nadd_left Ordinal.le_nadd_left
+
+theorem le_self_nadd {a b} : a ≤ a ♯ b := by simpa using nadd_le_nadd_left (Ordinal.zero_le b) a
+#align ordinal.le_self_nadd Ordinal.le_self_nadd
+
+theorem le_nadd_right {a b c} (h : a ≤ b) : a ≤ b ♯ c :=
+  le_self_nadd.trans (nadd_le_nadd_right h c)
+#align ordinal.le_nadd_right Ordinal.le_nadd_right
+
+theorem nadd_left_comm : ∀ a b c, a ♯ (b ♯ c) = b ♯ (a ♯ c) :=
+  @add_left_comm NatOrdinal _
+#align ordinal.nadd_left_comm Ordinal.nadd_left_comm
+
+theorem nadd_right_comm : ∀ a b c, a ♯ b ♯ c = a ♯ c ♯ b :=
+  @add_right_comm NatOrdinal _
+#align ordinal.nadd_right_comm Ordinal.nadd_right_comm
+
+/-! ### Natural multiplication -/
+
+
+variable {a b c d : Ordinal.{u}}
+
+theorem nmul_def (a b : Ordinal) :
+    a ⨳ b = sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'} := by rw [nmul]
+#align ordinal.nmul_def Ordinal.nmul_def
+
+/-- The set in the definition of `nmul` is nonempty. -/
+theorem nmul_nonempty (a b : Ordinal.{u}) :
+    {c : Ordinal.{u} | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}.Nonempty :=
+  ⟨_, fun a' ha b' hb => (lt_blsub₂.{u, u, u} _ ha hb).trans_le le_self_nadd⟩
+#align ordinal.nmul_nonempty Ordinal.nmul_nonempty
+
+theorem nmul_nadd_lt {a' b' : Ordinal} (ha : a' < a) (hb : b' < b) :
+    a' ⨳ b ♯ a ⨳ b' < a ⨳ b ♯ a' ⨳ b' := by rw [nmul_def a b];
+  exact csInf_mem (nmul_nonempty a b) a' ha b' hb
+#align ordinal.nmul_nadd_lt Ordinal.nmul_nadd_lt
+
+theorem nmul_nadd_le {a' b' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
+    a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b' :=
+  by
+  rcases lt_or_eq_of_le ha with (ha | rfl)
+  · rcases lt_or_eq_of_le hb with (hb | rfl)
+    · exact (nmul_nadd_lt ha hb).le
+    · rw [nadd_comm]
+  · exact le_rfl
+#align ordinal.nmul_nadd_le Ordinal.nmul_nadd_le
+
+theorem lt_nmul_iff : c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b' :=
+  by
+  refine' ⟨fun h => _, _⟩
+  · rw [nmul] at h 
+    simpa using not_mem_of_lt_csInf h ⟨0, fun _ _ => bot_le⟩
+  · rintro ⟨a', ha, b', hb, h⟩
+    have := h.trans_lt (nmul_nadd_lt ha hb)
+    rwa [nadd_lt_nadd_iff_right] at this 
+#align ordinal.lt_nmul_iff Ordinal.lt_nmul_iff
+
+theorem nmul_le_iff : a ⨳ b ≤ c ↔ ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b' := by
+  rw [← not_iff_not]; simp [lt_nmul_iff]
+#align ordinal.nmul_le_iff Ordinal.nmul_le_iff
+
+theorem nmul_comm : ∀ a b, a ⨳ b = b ⨳ a
+  | a, b => by
+    rw [nmul, nmul]
+    congr; ext x; constructor <;> intro H c hc d hd
+    · rw [nadd_comm, ← nmul_comm, ← nmul_comm a, ← nmul_comm d]
+      exact H _ hd _ hc
+    · rw [nadd_comm, nmul_comm, nmul_comm c, nmul_comm c]
+      exact H _ hd _ hc
+decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+#align ordinal.nmul_comm Ordinal.nmul_comm
+
+@[simp]
+theorem nmul_zero (a) : a ⨳ 0 = 0 := by rw [← Ordinal.le_zero, nmul_le_iff];
+  exact fun _ _ a ha => (Ordinal.not_lt_zero a ha).elim
+#align ordinal.nmul_zero Ordinal.nmul_zero
+
+@[simp]
+theorem zero_nmul (a) : 0 ⨳ a = 0 := by rw [nmul_comm, nmul_zero]
+#align ordinal.zero_nmul Ordinal.zero_nmul
+
+@[simp]
+theorem nmul_one : ∀ a, a ⨳ 1 = a
+  | a => by
+    rw [nmul]
+    simp only [lt_one_iff_zero, forall_eq, nmul_zero, nadd_zero]
+    convert csInf_Ici
+    ext b
+    refine' ⟨fun H => le_of_forall_lt fun c hc => _, fun ha c hc => _⟩
+    · simpa only [nmul_one] using H c hc
+    · simpa only [nmul_one] using hc.trans_le ha
+#align ordinal.nmul_one Ordinal.nmul_one
+
+@[simp]
+theorem one_nmul (a) : 1 ⨳ a = a := by rw [nmul_comm, nmul_one]
+#align ordinal.one_nmul Ordinal.one_nmul
+
+theorem nmul_lt_nmul_of_pos_left (h₁ : a < b) (h₂ : 0 < c) : c ⨳ a < c ⨳ b :=
+  lt_nmul_iff.2 ⟨0, h₂, a, h₁, by simp⟩
+#align ordinal.nmul_lt_nmul_of_pos_left Ordinal.nmul_lt_nmul_of_pos_left
+
+theorem nmul_lt_nmul_of_pos_right (h₁ : a < b) (h₂ : 0 < c) : a ⨳ c < b ⨳ c :=
+  lt_nmul_iff.2 ⟨a, h₁, 0, h₂, by simp⟩
+#align ordinal.nmul_lt_nmul_of_pos_right Ordinal.nmul_lt_nmul_of_pos_right
+
+theorem nmul_le_nmul_of_nonneg_left (h₁ : a ≤ b) (h₂ : 0 ≤ c) : c ⨳ a ≤ c ⨳ b :=
+  by
+  rcases lt_or_eq_of_le h₁ with (h₁ | rfl) <;> rcases lt_or_eq_of_le h₂ with (h₂ | rfl)
+  · exact (nmul_lt_nmul_of_pos_left h₁ h₂).le
+  all_goals simp
+#align ordinal.nmul_le_nmul_of_nonneg_left Ordinal.nmul_le_nmul_of_nonneg_left
+
+theorem nmul_le_nmul_of_nonneg_right (h₁ : a ≤ b) (h₂ : 0 ≤ c) : a ⨳ c ≤ b ⨳ c :=
+  by
+  rw [nmul_comm, nmul_comm b]
+  exact nmul_le_nmul_of_nonneg_left h₁ h₂
+#align ordinal.nmul_le_nmul_of_nonneg_right Ordinal.nmul_le_nmul_of_nonneg_right
+
+theorem nmul_nadd : ∀ a b c, a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
+  | a, b, c =>
+    by
+    apply
+      le_antisymm (nmul_le_iff.2 fun a' ha d hd => _) (nadd_le_iff.2 ⟨fun d hd => _, fun d hd => _⟩)
+    · rw [nmul_nadd]
+      rcases lt_nadd_iff.1 hd with (⟨b', hb, hd⟩ | ⟨c', hc, hd⟩)
+      · have := nadd_lt_nadd_of_lt_of_le (nmul_nadd_lt ha hb) (nmul_nadd_le ha.le hd)
+        rw [nmul_nadd, nmul_nadd] at this 
+        simp only [nadd_assoc] at this 
+        rwa [nadd_left_comm, nadd_left_comm _ (a ⨳ b'), nadd_left_comm (a ⨳ b),
+          nadd_lt_nadd_iff_left, nadd_left_comm (a' ⨳ b), nadd_left_comm (a ⨳ b),
+          nadd_lt_nadd_iff_left, ← nadd_assoc, ← nadd_assoc] at this 
+      · have := nadd_lt_nadd_of_le_of_lt (nmul_nadd_le ha.le hd) (nmul_nadd_lt ha hc)
+        rw [nmul_nadd, nmul_nadd] at this 
+        simp only [nadd_assoc] at this 
+        rwa [nadd_left_comm, nadd_comm (a ⨳ c), nadd_left_comm (a' ⨳ d), nadd_left_comm (a ⨳ c'),
+          nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, nadd_comm (a' ⨳ c), nadd_left_comm (a ⨳ d),
+          nadd_left_comm (a' ⨳ b), nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, nadd_comm (a ⨳ d),
+          nadd_comm (a' ⨳ d), ← nadd_assoc, ← nadd_assoc] at this 
+    · rcases lt_nmul_iff.1 hd with ⟨a', ha, b', hb, hd⟩
+      have := nadd_lt_nadd_of_le_of_lt hd (nmul_nadd_lt ha (nadd_lt_nadd_right hb c))
+      rw [nmul_nadd, nmul_nadd, nmul_nadd a'] at this 
+      simp only [nadd_assoc] at this 
+      rwa [nadd_left_comm (a' ⨳ b'), nadd_left_comm, nadd_lt_nadd_iff_left, nadd_left_comm,
+        nadd_left_comm _ (a' ⨳ b'), nadd_left_comm (a ⨳ b'), nadd_lt_nadd_iff_left,
+        nadd_left_comm (a' ⨳ c), nadd_left_comm, nadd_lt_nadd_iff_left, nadd_left_comm,
+        nadd_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left] at this 
+    · rcases lt_nmul_iff.1 hd with ⟨a', ha, c', hc, hd⟩
+      have := nadd_lt_nadd_of_lt_of_le (nmul_nadd_lt ha (nadd_lt_nadd_left hc b)) hd
+      rw [nmul_nadd, nmul_nadd, nmul_nadd a'] at this 
+      simp only [nadd_assoc] at this 
+      rwa [nadd_left_comm _ (a' ⨳ b), nadd_lt_nadd_iff_left, nadd_left_comm (a' ⨳ c'),
+        nadd_left_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left, nadd_left_comm, nadd_comm (a' ⨳ c'),
+        nadd_left_comm _ (a ⨳ c'), nadd_lt_nadd_iff_left, nadd_comm _ (a' ⨳ c'),
+        nadd_comm _ (a' ⨳ c'), nadd_left_comm, nadd_lt_nadd_iff_left] at this 
+decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+#align ordinal.nmul_nadd Ordinal.nmul_nadd
+
+theorem nadd_nmul (a b c) : (a ♯ b) ⨳ c = a ⨳ c ♯ b ⨳ c := by
+  rw [nmul_comm, nmul_nadd, nmul_comm, nmul_comm c]
+#align ordinal.nadd_nmul Ordinal.nadd_nmul
+
+theorem nmul_nadd_lt₃ {a' b' c' : Ordinal} (ha : a' < a) (hb : b' < b) (hc : c' < c) :
+    a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' <
+      a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
+  by simpa only [nadd_nmul, ← nadd_assoc] using nmul_nadd_lt (nmul_nadd_lt ha hb) hc
+#align ordinal.nmul_nadd_lt₃ Ordinal.nmul_nadd_lt₃
+
+theorem nmul_nadd_le₃ {a' b' c' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (hc : c' ≤ c) :
+    a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' ≤
+      a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
+  by simpa only [nadd_nmul, ← nadd_assoc] using nmul_nadd_le (nmul_nadd_le ha hb) hc
+#align ordinal.nmul_nadd_le₃ Ordinal.nmul_nadd_le₃
+
+theorem nmul_nadd_lt₃' {a' b' c' : Ordinal} (ha : a' < a) (hb : b' < b) (hc : c' < c) :
+    a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
+      a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
+  by
+  simp only [nmul_comm _ (_ ⨳ _)]
+  convert nmul_nadd_lt₃ hb hc ha using 1 <;>
+    · simp only [nadd_eq_add, NatOrdinal.toOrdinal_toNatOrdinal]; abel
+#align ordinal.nmul_nadd_lt₃' Ordinal.nmul_nadd_lt₃'
+
+theorem nmul_nadd_le₃' {a' b' c' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (hc : c' ≤ c) :
+    a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') ≤
+      a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
+  by
+  simp only [nmul_comm _ (_ ⨳ _)]
+  convert nmul_nadd_le₃ hb hc ha using 1 <;>
+    · simp only [nadd_eq_add, NatOrdinal.toOrdinal_toNatOrdinal]; abel
+#align ordinal.nmul_nadd_le₃' Ordinal.nmul_nadd_le₃'
+
+theorem lt_nmul_iff₃ :
+    d < a ⨳ b ⨳ c ↔
+      ∃ a' < a,
+        ∃ b' < b,
+          ∃ c' < c,
+            d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' ≤
+              a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' :=
+  by
+  refine' ⟨fun h => _, _⟩
+  · rcases lt_nmul_iff.1 h with ⟨e, he, c', hc, H₁⟩
+    rcases lt_nmul_iff.1 he with ⟨a', ha, b', hb, H₂⟩
+    refine' ⟨a', ha, b', hb, c', hc, _⟩
+    have := nadd_le_nadd H₁ (nmul_nadd_le H₂ hc.le)
+    simp only [nadd_nmul, nadd_assoc] at this 
+    rw [nadd_left_comm, nadd_left_comm d, nadd_left_comm, nadd_le_nadd_iff_left,
+      nadd_left_comm (a ⨳ b' ⨳ c), nadd_left_comm (a' ⨳ b ⨳ c), nadd_left_comm (a ⨳ b ⨳ c'),
+      nadd_le_nadd_iff_left, nadd_left_comm (a ⨳ b ⨳ c'), nadd_left_comm (a ⨳ b ⨳ c')] at this 
+    simpa only [nadd_assoc]
+  · rintro ⟨a', ha, b', hb, c', hc, h⟩
+    have := h.trans_lt (nmul_nadd_lt₃ ha hb hc)
+    repeat' rwa [nadd_lt_nadd_iff_right] at this 
+#align ordinal.lt_nmul_iff₃ Ordinal.lt_nmul_iff₃
+
+theorem nmul_le_iff₃ :
+    a ⨳ b ⨳ c ≤ d ↔
+      ∀ a' < a,
+        ∀ b' < b,
+          ∀ c' < c,
+            a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' <
+              d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' :=
+  by rw [← not_iff_not]; simp [lt_nmul_iff₃]
+#align ordinal.nmul_le_iff₃ Ordinal.nmul_le_iff₃
+
+theorem lt_nmul_iff₃' :
+    d < a ⨳ (b ⨳ c) ↔
+      ∃ a' < a,
+        ∃ b' < b,
+          ∃ c' < c,
+            d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') ≤
+              a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') :=
+  by
+  simp only [nmul_comm _ (_ ⨳ _), lt_nmul_iff₃, nadd_eq_add, NatOrdinal.toOrdinal_toNatOrdinal]
+  constructor <;> rintro ⟨b', hb, c', hc, a', ha, h⟩
+  · use a', ha, b', hb, c', hc; convert h using 1 <;> abel
+  · use c', hc, a', ha, b', hb; convert h using 1 <;> abel
+#align ordinal.lt_nmul_iff₃' Ordinal.lt_nmul_iff₃'
+
+theorem nmul_le_iff₃' :
+    a ⨳ (b ⨳ c) ≤ d ↔
+      ∀ a' < a,
+        ∀ b' < b,
+          ∀ c' < c,
+            a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
+              d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') :=
+  by rw [← not_iff_not]; simp [lt_nmul_iff₃']
+#align ordinal.nmul_le_iff₃' Ordinal.nmul_le_iff₃'
+
+theorem nmul_assoc : ∀ a b c, a ⨳ b ⨳ c = a ⨳ (b ⨳ c)
+  | a, b, c => by
+    apply le_antisymm
+    · rw [nmul_le_iff₃]
+      intro a' ha b' hb c' hc
+      repeat' rw [nmul_assoc]
+      exact nmul_nadd_lt₃' ha hb hc
+    · rw [nmul_le_iff₃']
+      intro a' ha b' hb c' hc
+      repeat' rw [← nmul_assoc]
+      exact nmul_nadd_lt₃ ha hb hc
+decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+#align ordinal.nmul_assoc Ordinal.nmul_assoc
+
 end Ordinal
 
+open Ordinal
+
+instance : Mul NatOrdinal :=
+  ⟨nmul⟩
+
+instance : OrderedCommSemiring NatOrdinal :=
+  { NatOrdinal.orderedCancelAddCommMonoid,
+    NatOrdinal.linearOrder with
+    mul := (· * ·)
+    left_distrib := nmul_nadd
+    right_distrib := nadd_nmul
+    zero_mul := zero_nmul
+    mul_zero := nmul_zero
+    mul_assoc := nmul_assoc
+    one := 1
+    one_mul := one_nmul
+    mul_one := nmul_one
+    mul_comm := nmul_comm
+    zero_le_one := @zero_le_one Ordinal _ _ _ _
+    mul_le_mul_of_nonneg_left := fun a b c => nmul_le_nmul_of_nonneg_left
+    mul_le_mul_of_nonneg_right := fun a b c => nmul_le_nmul_of_nonneg_right }
+
+namespace Ordinal
+
+theorem nmul_eq_mul (a b) : a ⨳ b = (a.toNatOrdinal * b.toNatOrdinal).toOrdinal :=
+  rfl
+#align ordinal.nmul_eq_mul Ordinal.nmul_eq_mul
+
+theorem nmul_nadd_one : ∀ a b, a ⨳ (b ♯ 1) = a ⨳ b ♯ a :=
+  @mul_add_one NatOrdinal _ _ _
+#align ordinal.nmul_nadd_one Ordinal.nmul_nadd_one
+
+theorem nadd_one_nmul : ∀ a b, (a ♯ 1) ⨳ b = a ⨳ b ♯ b :=
+  @add_one_mul NatOrdinal _ _ _
+#align ordinal.nadd_one_nmul Ordinal.nadd_one_nmul
+
+theorem nmul_succ (a b) : a ⨳ succ b = a ⨳ b ♯ a := by rw [← nadd_one, nmul_nadd_one]
+#align ordinal.nmul_succ Ordinal.nmul_succ
+
+theorem succ_nmul (a b) : succ a ⨳ b = a ⨳ b ♯ b := by rw [← nadd_one, nadd_one_nmul]
+#align ordinal.succ_nmul Ordinal.succ_nmul
+
+theorem nmul_add_one : ∀ a b, a ⨳ (b + 1) = a ⨳ b ♯ a :=
+  nmul_succ
+#align ordinal.nmul_add_one Ordinal.nmul_add_one
+
+theorem add_one_nmul : ∀ a b, (a + 1) ⨳ b = a ⨳ b ♯ b :=
+  succ_nmul
+#align ordinal.add_one_nmul Ordinal.add_one_nmul
+
+end Ordinal
+
+namespace NatOrdinal
+
+open Ordinal
+
+theorem mul_le_nmul (a b : Ordinal.{u}) : a * b ≤ a ⨳ b :=
+  by
+  apply b.limit_rec_on
+  · simp
+  · intro c h
+    rw [mul_succ, nmul_succ]
+    exact (add_le_nadd _ a).trans (nadd_le_nadd_right h a)
+  · intro c hc H
+    rcases eq_zero_or_pos a with (rfl | ha)
+    · simp
+    · rw [← IsNormal.blsub_eq.{u, u} (mul_is_normal ha) hc, blsub_le_iff]
+      exact fun i hi => (H i hi).trans_lt (nmul_lt_nmul_of_pos_left hi ha)
+#align nat_ordinal.mul_le_nmul NatOrdinal.mul_le_nmul
+
+end NatOrdinal
+

bump to nightly-2023-06-20-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

9b351f8c

Diff

@@ -305,7 +305,7 @@ variable (a b)
 theorem nadd_comm : ∀ a b, a ♯ b = b ♯ a
   | a, b => by
     rw [nadd_def, nadd_def, max_comm]
-    congr <;> ext (c hc) <;> apply nadd_comm
+    congr <;> ext c hc <;> apply nadd_comm
 decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd_comm Ordinal.nadd_comm
 -/
@@ -333,7 +333,7 @@ theorem nadd_assoc : ∀ a b c, a ♯ b ♯ c = a ♯ (b ♯ c)
   | a, b, c =>
     by
     rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
-    · congr <;> ext (d hd) <;> apply nadd_assoc
+    · congr <;> ext d hd <;> apply nadd_assoc
     · exact fun i j _ _ h => nadd_le_nadd_left h a
     · exact fun i j _ _ h => nadd_le_nadd_right h c
 decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
@@ -347,7 +347,7 @@ theorem nadd_zero : a ♯ 0 = a :=
   induction' a using Ordinal.induction with a IH
   rw [nadd_def, blsub_zero, max_zero_right]
   convert blsub_id a
-  ext (b hb)
+  ext b hb
   exact IH _ hb
 #align ordinal.nadd_zero Ordinal.nadd_zero
 -/

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -91,10 +91,12 @@ theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
 #align nat_ordinal.to_ordinal_symm_eq NatOrdinal.toOrdinal_symm_eq
 -/
 
+#print NatOrdinal.toOrdinal_toNatOrdinal /-
 @[simp]
 theorem toOrdinal_toNatOrdinal (a : NatOrdinal) : a.toOrdinal.toNatOrdinal = a :=
   rfl
 #align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinal
+-/
 
 #print NatOrdinal.lt_wf /-
 theorem lt_wf : @WellFounded NatOrdinal (· < ·) :=
@@ -108,44 +110,60 @@ instance : WellFoundedLT NatOrdinal :=
 instance : IsWellOrder NatOrdinal (· < ·) :=
   Ordinal.HasLt.Lt.isWellOrder
 
+#print NatOrdinal.toOrdinal_zero /-
 @[simp]
 theorem toOrdinal_zero : toOrdinal 0 = 0 :=
   rfl
 #align nat_ordinal.to_ordinal_zero NatOrdinal.toOrdinal_zero
+-/
 
+#print NatOrdinal.toOrdinal_one /-
 @[simp]
 theorem toOrdinal_one : toOrdinal 1 = 1 :=
   rfl
 #align nat_ordinal.to_ordinal_one NatOrdinal.toOrdinal_one
+-/
 
+#print NatOrdinal.toOrdinal_eq_zero /-
 @[simp]
 theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
   Iff.rfl
 #align nat_ordinal.to_ordinal_eq_zero NatOrdinal.toOrdinal_eq_zero
+-/
 
+#print NatOrdinal.toOrdinal_eq_one /-
 @[simp]
 theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
   Iff.rfl
 #align nat_ordinal.to_ordinal_eq_one NatOrdinal.toOrdinal_eq_one
+-/
 
+#print NatOrdinal.toOrdinal_max /-
 @[simp]
 theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
   rfl
 #align nat_ordinal.to_ordinal_max NatOrdinal.toOrdinal_max
+-/
 
+#print NatOrdinal.toOrdinal_min /-
 @[simp]
 theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
   rfl
 #align nat_ordinal.to_ordinal_min NatOrdinal.toOrdinal_min
+-/
 
+#print NatOrdinal.succ_def /-
 theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
   rfl
 #align nat_ordinal.succ_def NatOrdinal.succ_def
+-/
 
+#print NatOrdinal.rec /-
 /-- A recursor for `nat_ordinal`. Use as `induction x using nat_ordinal.rec`. -/
 protected def rec {β : NatOrdinal → Sort _} (h : ∀ a, β (toNatOrdinal a)) : ∀ a, β a := fun a =>
   h a.toOrdinal
 #align nat_ordinal.rec NatOrdinal.rec
+-/
 
 #print NatOrdinal.induction /-
 /-- `ordinal.induction` but for `nat_ordinal`. -/
@@ -167,41 +185,55 @@ theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal :=
 #align ordinal.to_nat_ordinal_symm_eq Ordinal.toNatOrdinal_symm_eq
 -/
 
+#print Ordinal.toNatOrdinal_toOrdinal /-
 @[simp]
 theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
   rfl
 #align ordinal.to_nat_ordinal_to_ordinal Ordinal.toNatOrdinal_toOrdinal
+-/
 
+#print Ordinal.toNatOrdinal_zero /-
 @[simp]
 theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
   rfl
 #align ordinal.to_nat_ordinal_zero Ordinal.toNatOrdinal_zero
+-/
 
+#print Ordinal.toNatOrdinal_one /-
 @[simp]
 theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
   rfl
 #align ordinal.to_nat_ordinal_one Ordinal.toNatOrdinal_one
+-/
 
+#print Ordinal.toNatOrdinal_eq_zero /-
 @[simp]
 theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
   Iff.rfl
 #align ordinal.to_nat_ordinal_eq_zero Ordinal.toNatOrdinal_eq_zero
+-/
 
+#print Ordinal.toNatOrdinal_eq_one /-
 @[simp]
 theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
   Iff.rfl
 #align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_one
+-/
 
+#print Ordinal.toNatOrdinal_max /-
 @[simp]
 theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOrdinal :=
   rfl
 #align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_max
+-/
 
+#print Ordinal.toNatOrdinal_min /-
 @[simp]
 theorem toNatOrdinal_min :
     (LinearOrder.min a b).toNatOrdinal = LinearOrder.min a.toNatOrdinal b.toNatOrdinal :=
   rfl
 #align ordinal.to_nat_ordinal_min Ordinal.toNatOrdinal_min
+-/
 
 #print Ordinal.nadd /-
 /-- Natural addition on ordinals `a ♯ b`, also known as the Hessenberg sum, is recursively defined
@@ -216,17 +248,20 @@ decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd Ordinal.nadd
 -/
 
--- mathport name: ordinal.nadd
 scoped[NaturalOps] infixl:65 " ♯ " => Ordinal.nadd
 
+#print Ordinal.nadd_def /-
 theorem nadd_def (a b : Ordinal) :
     a ♯ b = max (blsub.{u, u} a fun a' h => a' ♯ b) (blsub.{u, u} b fun b' h => a ♯ b') := by
   rw [nadd]
 #align ordinal.nadd_def Ordinal.nadd_def
+-/
 
+#print Ordinal.lt_nadd_iff /-
 theorem lt_nadd_iff : a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c' := by rw [nadd_def];
   simp [lt_blsub_iff]
 #align ordinal.lt_nadd_iff Ordinal.lt_nadd_iff
+-/
 
 #print Ordinal.nadd_le_iff /-
 theorem nadd_le_iff : b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a := by rw [nadd_def];
@@ -275,6 +310,7 @@ decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd_comm Ordinal.nadd_comm
 -/
 
+#print Ordinal.blsub_nadd_of_mono /-
 theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
     (hf : ∀ {i j} (hi hj), i ≤ j → f i hi ≤ f j hj) :
     blsub _ f =
@@ -290,6 +326,7 @@ theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
     rintro c ⟨d, hd, rfl⟩
     apply mem_brange_self
 #align ordinal.blsub_nadd_of_mono Ordinal.blsub_nadd_of_mono
+-/
 
 #print Ordinal.nadd_assoc /-
 theorem nadd_assoc : ∀ a b c, a ♯ b ♯ c = a ♯ (b ♯ c)
@@ -321,6 +358,7 @@ theorem zero_nadd : 0 ♯ a = a := by rw [nadd_comm, nadd_zero]
 #align ordinal.zero_nadd Ordinal.zero_nadd
 -/
 
+#print Ordinal.nadd_one /-
 @[simp]
 theorem nadd_one : a ♯ 1 = succ a :=
   by
@@ -329,10 +367,13 @@ theorem nadd_one : a ♯ 1 = succ a :=
   intro i hi
   rwa [IH i hi, succ_lt_succ_iff]
 #align ordinal.nadd_one Ordinal.nadd_one
+-/
 
+#print Ordinal.one_nadd /-
 @[simp]
 theorem one_nadd : 1 ♯ a = succ a := by rw [nadd_comm, nadd_one]
 #align ordinal.one_nadd Ordinal.one_nadd
+-/
 
 #print Ordinal.nadd_succ /-
 theorem nadd_succ : a ♯ succ b = succ (a ♯ b) := by rw [← nadd_one (a ♯ b), nadd_assoc, nadd_one]
@@ -414,11 +455,14 @@ instance : OrderedCancelAddCommMonoid NatOrdinal :=
 instance : AddMonoidWithOne NatOrdinal :=
   AddMonoidWithOne.unary
 
+#print NatOrdinal.add_one_eq_succ /-
 @[simp]
 theorem add_one_eq_succ : ∀ a : NatOrdinal, a + 1 = succ a :=
   nadd_one
 #align nat_ordinal.add_one_eq_succ NatOrdinal.add_one_eq_succ
+-/
 
+#print NatOrdinal.toOrdinal_cast_nat /-
 @[simp]
 theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n :=
   by
@@ -428,6 +472,7 @@ theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n :=
     rw [hn]
     apply nadd_one
 #align nat_ordinal.to_ordinal_cast_nat NatOrdinal.toOrdinal_cast_nat
+-/
 
 end NatOrdinal
 
@@ -437,9 +482,11 @@ open scoped NaturalOps
 
 namespace Ordinal
 
+#print Ordinal.toNatOrdinal_cast_nat /-
 @[simp]
 theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n := by rw [← to_ordinal_cast_nat n]; rfl
 #align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_nat
+-/
 
 #print Ordinal.lt_of_nadd_lt_nadd_left /-
 theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c :=

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -57,7 +57,8 @@ noncomputable section
 #print NatOrdinal /-
 /-- A type synonym for ordinals with natural addition and multiplication. -/
 def NatOrdinal : Type _ :=
-  Ordinal deriving Zero, Inhabited, One, LinearOrder, SuccOrder, WellFoundedRelation
+  Ordinal
+deriving Zero, Inhabited, One, LinearOrder, SuccOrder, WellFoundedRelation
 #align nat_ordinal NatOrdinal
 -/
 
@@ -210,9 +211,8 @@ to normal ordinal addition, it is commutative.
 Natural addition can equivalently be characterized as the ordinal resulting from adding up
 corresponding coefficients in the Cantor normal forms of `a` and `b`. -/
 noncomputable def nadd : Ordinal → Ordinal → Ordinal
-  | a, b =>
-    max (blsub.{u, u} a fun a' h => nadd a' b) (blsub.{u, u} b fun b' h => nadd a b')decreasing_by
-  solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+  | a, b => max (blsub.{u, u} a fun a' h => nadd a' b) (blsub.{u, u} b fun b' h => nadd a b')
+decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd Ordinal.nadd
 -/
 
@@ -270,8 +270,8 @@ variable (a b)
 theorem nadd_comm : ∀ a b, a ♯ b = b ♯ a
   | a, b => by
     rw [nadd_def, nadd_def, max_comm]
-    congr <;> ext (c hc) <;> apply nadd_comm decreasing_by
-  solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+    congr <;> ext (c hc) <;> apply nadd_comm
+decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd_comm Ordinal.nadd_comm
 -/
 
@@ -298,8 +298,8 @@ theorem nadd_assoc : ∀ a b c, a ♯ b ♯ c = a ♯ (b ♯ c)
     rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
     · congr <;> ext (d hd) <;> apply nadd_assoc
     · exact fun i j _ _ h => nadd_le_nadd_left h a
-    · exact fun i j _ _ h => nadd_le_nadd_right h c decreasing_by
-  solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+    · exact fun i j _ _ h => nadd_le_nadd_right h c
+decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd_assoc Ordinal.nadd_assoc
 -/

bump to nightly-2023-05-28-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

8d353152

Diff

@@ -61,17 +61,21 @@ def NatOrdinal : Type _ :=
 #align nat_ordinal NatOrdinal
 -/
 
+#print Ordinal.toNatOrdinal /-
 /-- The identity function between `ordinal` and `nat_ordinal`. -/
 @[match_pattern]
 def Ordinal.toNatOrdinal : Ordinal ≃o NatOrdinal :=
   OrderIso.refl _
 #align ordinal.to_nat_ordinal Ordinal.toNatOrdinal
+-/
 
+#print NatOrdinal.toOrdinal /-
 /-- The identity function between `nat_ordinal` and `ordinal`. -/
 @[match_pattern]
 def NatOrdinal.toOrdinal : NatOrdinal ≃o Ordinal :=
   OrderIso.refl _
 #align nat_ordinal.to_ordinal NatOrdinal.toOrdinal
+-/
 
 open Ordinal
 
@@ -79,19 +83,23 @@ namespace NatOrdinal
 
 variable {a b c : NatOrdinal.{u}}
 
+#print NatOrdinal.toOrdinal_symm_eq /-
 @[simp]
 theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
   rfl
 #align nat_ordinal.to_ordinal_symm_eq NatOrdinal.toOrdinal_symm_eq
+-/
 
 @[simp]
 theorem toOrdinal_toNatOrdinal (a : NatOrdinal) : a.toOrdinal.toNatOrdinal = a :=
   rfl
 #align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinal
 
+#print NatOrdinal.lt_wf /-
 theorem lt_wf : @WellFounded NatOrdinal (· < ·) :=
   Ordinal.lt_wf
 #align nat_ordinal.lt_wf NatOrdinal.lt_wf
+-/
 
 instance : WellFoundedLT NatOrdinal :=
   Ordinal.wellFoundedLT
@@ -138,10 +146,12 @@ protected def rec {β : NatOrdinal → Sort _} (h : ∀ a, β (toNatOrdinal a))
   h a.toOrdinal
 #align nat_ordinal.rec NatOrdinal.rec
 
+#print NatOrdinal.induction /-
 /-- `ordinal.induction` but for `nat_ordinal`. -/
 theorem induction {p : NatOrdinal → Prop} : ∀ (i) (h : ∀ j, (∀ k, k < j → p k) → p j), p i :=
   Ordinal.induction
 #align nat_ordinal.induction NatOrdinal.induction
+-/
 
 end NatOrdinal
 
@@ -149,10 +159,12 @@ namespace Ordinal
 
 variable {a b c : Ordinal.{u}}
 
+#print Ordinal.toNatOrdinal_symm_eq /-
 @[simp]
 theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal :=
   rfl
 #align ordinal.to_nat_ordinal_symm_eq Ordinal.toNatOrdinal_symm_eq
+-/
 
 @[simp]
 theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
@@ -216,31 +228,41 @@ theorem lt_nadd_iff : a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' <
   simp [lt_blsub_iff]
 #align ordinal.lt_nadd_iff Ordinal.lt_nadd_iff
 
+#print Ordinal.nadd_le_iff /-
 theorem nadd_le_iff : b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a := by rw [nadd_def];
   simp [blsub_le_iff]
 #align ordinal.nadd_le_iff Ordinal.nadd_le_iff
+-/
 
+#print Ordinal.nadd_lt_nadd_left /-
 theorem nadd_lt_nadd_left (h : b < c) (a) : a ♯ b < a ♯ c :=
   lt_nadd_iff.2 (Or.inr ⟨b, h, le_rfl⟩)
 #align ordinal.nadd_lt_nadd_left Ordinal.nadd_lt_nadd_left
+-/
 
+#print Ordinal.nadd_lt_nadd_right /-
 theorem nadd_lt_nadd_right (h : b < c) (a) : b ♯ a < c ♯ a :=
   lt_nadd_iff.2 (Or.inl ⟨b, h, le_rfl⟩)
 #align ordinal.nadd_lt_nadd_right Ordinal.nadd_lt_nadd_right
+-/
 
+#print Ordinal.nadd_le_nadd_left /-
 theorem nadd_le_nadd_left (h : b ≤ c) (a) : a ♯ b ≤ a ♯ c :=
   by
   rcases lt_or_eq_of_le h with (h | rfl)
   · exact (nadd_lt_nadd_left h a).le
   · exact le_rfl
 #align ordinal.nadd_le_nadd_left Ordinal.nadd_le_nadd_left
+-/
 
+#print Ordinal.nadd_le_nadd_right /-
 theorem nadd_le_nadd_right (h : b ≤ c) (a) : b ♯ a ≤ c ♯ a :=
   by
   rcases lt_or_eq_of_le h with (h | rfl)
   · exact (nadd_lt_nadd_right h a).le
   · exact le_rfl
 #align ordinal.nadd_le_nadd_right Ordinal.nadd_le_nadd_right
+-/
 
 variable (a b)
 
@@ -338,6 +360,7 @@ theorem nat_nadd (n : ℕ) : ↑n ♯ a = a + n := by rw [nadd_comm, nadd_nat]
 #align ordinal.nat_nadd Ordinal.nat_nadd
 -/
 
+#print Ordinal.add_le_nadd /-
 theorem add_le_nadd : a + b ≤ a ♯ b := by
   apply b.limit_rec_on
   · simp
@@ -347,6 +370,7 @@ theorem add_le_nadd : a + b ≤ a ♯ b := by
     rw [← IsNormal.blsub_eq.{u, u} (add_is_normal a) hc, blsub_le_iff]
     exact fun i hi => (H i hi).trans_lt (nadd_lt_nadd_left hi a)
 #align ordinal.add_le_nadd Ordinal.add_le_nadd
+-/
 
 end Ordinal
 
@@ -357,18 +381,24 @@ namespace NatOrdinal
 instance : Add NatOrdinal :=
   ⟨nadd⟩
 
+#print NatOrdinal.add_covariantClass_lt /-
 instance add_covariantClass_lt : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· < ·) :=
   ⟨fun a b c h => nadd_lt_nadd_left h a⟩
 #align nat_ordinal.add_covariant_class_lt NatOrdinal.add_covariantClass_lt
+-/
 
+#print NatOrdinal.add_covariantClass_le /-
 instance add_covariantClass_le : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => nadd_le_nadd_left h a⟩
 #align nat_ordinal.add_covariant_class_le NatOrdinal.add_covariantClass_le
+-/
 
+#print NatOrdinal.add_contravariantClass_le /-
 instance add_contravariantClass_le :
     ContravariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => by by_contra' h'; exact h.not_lt (add_lt_add_left h' a)⟩
 #align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_le
+-/
 
 instance : OrderedCancelAddCommMonoid NatOrdinal :=
   { NatOrdinal.linearOrder with
@@ -403,7 +433,7 @@ end NatOrdinal
 
 open NatOrdinal
 
-open NaturalOps
+open scoped NaturalOps
 
 namespace Ordinal
 
@@ -411,37 +441,53 @@ namespace Ordinal
 theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n := by rw [← to_ordinal_cast_nat n]; rfl
 #align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_nat
 
+#print Ordinal.lt_of_nadd_lt_nadd_left /-
 theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c :=
   @lt_of_add_lt_add_left NatOrdinal _ _ _
 #align ordinal.lt_of_nadd_lt_nadd_left Ordinal.lt_of_nadd_lt_nadd_left
+-/
 
+#print Ordinal.lt_of_nadd_lt_nadd_right /-
 theorem lt_of_nadd_lt_nadd_right : ∀ {a b c}, b ♯ a < c ♯ a → b < c :=
   @lt_of_add_lt_add_right NatOrdinal _ _ _
 #align ordinal.lt_of_nadd_lt_nadd_right Ordinal.lt_of_nadd_lt_nadd_right
+-/
 
+#print Ordinal.le_of_nadd_le_nadd_left /-
 theorem le_of_nadd_le_nadd_left : ∀ {a b c}, a ♯ b ≤ a ♯ c → b ≤ c :=
   @le_of_add_le_add_left NatOrdinal _ _ _
 #align ordinal.le_of_nadd_le_nadd_left Ordinal.le_of_nadd_le_nadd_left
+-/
 
+#print Ordinal.le_of_nadd_le_nadd_right /-
 theorem le_of_nadd_le_nadd_right : ∀ {a b c}, b ♯ a ≤ c ♯ a → b ≤ c :=
   @le_of_add_le_add_right NatOrdinal _ _ _
 #align ordinal.le_of_nadd_le_nadd_right Ordinal.le_of_nadd_le_nadd_right
+-/
 
+#print Ordinal.nadd_lt_nadd_iff_left /-
 theorem nadd_lt_nadd_iff_left : ∀ (a) {b c}, a ♯ b < a ♯ c ↔ b < c :=
   @add_lt_add_iff_left NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd_iff_left Ordinal.nadd_lt_nadd_iff_left
+-/
 
+#print Ordinal.nadd_lt_nadd_iff_right /-
 theorem nadd_lt_nadd_iff_right : ∀ (a) {b c}, b ♯ a < c ♯ a ↔ b < c :=
   @add_lt_add_iff_right NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd_iff_right Ordinal.nadd_lt_nadd_iff_right
+-/
 
+#print Ordinal.nadd_le_nadd_iff_left /-
 theorem nadd_le_nadd_iff_left : ∀ (a) {b c}, a ♯ b ≤ a ♯ c ↔ b ≤ c :=
   @add_le_add_iff_left NatOrdinal _ _ _ _
 #align ordinal.nadd_le_nadd_iff_left Ordinal.nadd_le_nadd_iff_left
+-/
 
+#print Ordinal.nadd_le_nadd_iff_right /-
 theorem nadd_le_nadd_iff_right : ∀ (a) {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c :=
   @add_le_add_iff_right NatOrdinal _ _ _ _
 #align ordinal.nadd_le_nadd_iff_right Ordinal.nadd_le_nadd_iff_right
+-/
 
 #print Ordinal.nadd_left_cancel /-
 theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c :=

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -61,24 +61,12 @@ def NatOrdinal : Type _ :=
 #align nat_ordinal NatOrdinal
 -/
 
-/- warning: ordinal.to_nat_ordinal -> Ordinal.toNatOrdinal is a dubious translation:
-lean 3 declaration is
-  OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))
-but is expected to have type
-  OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal Ordinal.toNatOrdinalₓ'. -/
 /-- The identity function between `ordinal` and `nat_ordinal`. -/
 @[match_pattern]
 def Ordinal.toNatOrdinal : Ordinal ≃o NatOrdinal :=
   OrderIso.refl _
 #align ordinal.to_nat_ordinal Ordinal.toNatOrdinal
 
-/- warning: nat_ordinal.to_ordinal -> NatOrdinal.toOrdinal is a dubious translation:
-lean 3 declaration is
-  OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))
-but is expected to have type
-  OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal NatOrdinal.toOrdinalₓ'. -/
 /-- The identity function between `nat_ordinal` and `ordinal`. -/
 @[match_pattern]
 def NatOrdinal.toOrdinal : NatOrdinal ≃o Ordinal :=
@@ -91,31 +79,16 @@ namespace NatOrdinal
 
 variable {a b c : NatOrdinal.{u}}
 
-/- warning: nat_ordinal.to_ordinal_symm_eq -> NatOrdinal.toOrdinal_symm_eq is a dubious translation:
-lean 3 declaration is
-  Eq.{succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (OrderIso.symm.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) NatOrdinal.toOrdinal.{u1}) Ordinal.toNatOrdinal.{u1}
-but is expected to have type
-  Eq.{succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) (OrderIso.symm.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) NatOrdinal.toOrdinal.{u1}) Ordinal.toNatOrdinal.{u1}
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_symm_eq NatOrdinal.toOrdinal_symm_eqₓ'. -/
 @[simp]
 theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
   rfl
 #align nat_ordinal.to_ordinal_symm_eq NatOrdinal.toOrdinal_symm_eq
 
-/- warning: nat_ordinal.to_ordinal_to_nat_ordinal -> NatOrdinal.toOrdinal_toNatOrdinal is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinalₓ'. -/
 @[simp]
 theorem toOrdinal_toNatOrdinal (a : NatOrdinal) : a.toOrdinal.toNatOrdinal = a :=
   rfl
 #align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinal
 
-/- warning: nat_ordinal.lt_wf -> NatOrdinal.lt_wf is a dubious translation:
-lean 3 declaration is
-  WellFounded.{succ (succ u1)} NatOrdinal.{u1} (LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toHasLt.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
-but is expected to have type
-  WellFounded.{succ (succ u1)} NatOrdinal.{u1} (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.227 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.229 : NatOrdinal.{u1}) => LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toLT.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.227 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.229)
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.lt_wf NatOrdinal.lt_wfₓ'. -/
 theorem lt_wf : @WellFounded NatOrdinal (· < ·) :=
   Ordinal.lt_wf
 #align nat_ordinal.lt_wf NatOrdinal.lt_wf
@@ -126,90 +99,45 @@ instance : WellFoundedLT NatOrdinal :=
 instance : IsWellOrder NatOrdinal (· < ·) :=
   Ordinal.HasLt.Lt.isWellOrder
 
-/- warning: nat_ordinal.to_ordinal_zero -> NatOrdinal.toOrdinal_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))
-but is expected to have type
-  Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_zero NatOrdinal.toOrdinal_zeroₓ'. -/
 @[simp]
 theorem toOrdinal_zero : toOrdinal 0 = 0 :=
   rfl
 #align nat_ordinal.to_ordinal_zero NatOrdinal.toOrdinal_zero
 
-/- warning: nat_ordinal.to_ordinal_one -> NatOrdinal.toOrdinal_one is a dubious translation:
-lean 3 declaration is
-  Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))
-but is expected to have type
-  Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_one NatOrdinal.toOrdinal_oneₓ'. -/
 @[simp]
 theorem toOrdinal_one : toOrdinal 1 = 1 :=
   rfl
 #align nat_ordinal.to_ordinal_one NatOrdinal.toOrdinal_one
 
-/- warning: nat_ordinal.to_ordinal_eq_zero -> NatOrdinal.toOrdinal_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1}))))
-but is expected to have type
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1})))
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_zero NatOrdinal.toOrdinal_eq_zeroₓ'. -/
 @[simp]
 theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
   Iff.rfl
 #align nat_ordinal.to_ordinal_eq_zero NatOrdinal.toOrdinal_eq_zero
 
-/- warning: nat_ordinal.to_ordinal_eq_one -> NatOrdinal.toOrdinal_eq_one is a dubious translation:
-lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1}))))
-but is expected to have type
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1})))
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_one NatOrdinal.toOrdinal_eq_oneₓ'. -/
 @[simp]
 theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
   Iff.rfl
 #align nat_ordinal.to_ordinal_eq_one NatOrdinal.toOrdinal_eq_one
 
-/- warning: nat_ordinal.to_ordinal_max -> NatOrdinal.toOrdinal_max is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_max NatOrdinal.toOrdinal_maxₓ'. -/
 @[simp]
 theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
   rfl
 #align nat_ordinal.to_ordinal_max NatOrdinal.toOrdinal_max
 
-/- warning: nat_ordinal.to_ordinal_min -> NatOrdinal.toOrdinal_min is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_min NatOrdinal.toOrdinal_minₓ'. -/
 @[simp]
 theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
   rfl
 #align nat_ordinal.to_ordinal_min NatOrdinal.toOrdinal_min
 
-/- warning: nat_ordinal.succ_def -> NatOrdinal.succ_def is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.succ_def NatOrdinal.succ_defₓ'. -/
 theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
   rfl
 #align nat_ordinal.succ_def NatOrdinal.succ_def
 
-/- warning: nat_ordinal.rec -> NatOrdinal.rec is a dubious translation:
-lean 3 declaration is
-  forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
-but is expected to have type
-  forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.rec NatOrdinal.recₓ'. -/
 /-- A recursor for `nat_ordinal`. Use as `induction x using nat_ordinal.rec`. -/
 protected def rec {β : NatOrdinal → Sort _} (h : ∀ a, β (toNatOrdinal a)) : ∀ a, β a := fun a =>
   h a.toOrdinal
 #align nat_ordinal.rec NatOrdinal.rec
 
-/- warning: nat_ordinal.induction -> NatOrdinal.induction is a dubious translation:
-lean 3 declaration is
-  forall {p : NatOrdinal.{u1} -> Prop} (i : NatOrdinal.{u1}), (forall (j : NatOrdinal.{u1}), (forall (k : NatOrdinal.{u1}), (LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toHasLt.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) k j) -> (p k)) -> (p j)) -> (p i)
-but is expected to have type
-  forall {p : NatOrdinal.{u1} -> Prop} (i : NatOrdinal.{u1}), (forall (j : NatOrdinal.{u1}), (forall (k : NatOrdinal.{u1}), (LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toLT.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) k j) -> (p k)) -> (p j)) -> (p i)
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.induction NatOrdinal.inductionₓ'. -/
 /-- `ordinal.induction` but for `nat_ordinal`. -/
 theorem induction {p : NatOrdinal → Prop} : ∀ (i) (h : ∀ j, (∀ k, k < j → p k) → p j), p i :=
   Ordinal.induction
@@ -221,80 +149,41 @@ namespace Ordinal
 
 variable {a b c : Ordinal.{u}}
 
-/- warning: ordinal.to_nat_ordinal_symm_eq -> Ordinal.toNatOrdinal_symm_eq is a dubious translation:
-lean 3 declaration is
-  Eq.{succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (OrderIso.symm.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) Ordinal.toNatOrdinal.{u1}) NatOrdinal.toOrdinal.{u1}
-but is expected to have type
-  Eq.{succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (OrderIso.symm.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) Ordinal.toNatOrdinal.{u1}) NatOrdinal.toOrdinal.{u1}
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_symm_eq Ordinal.toNatOrdinal_symm_eqₓ'. -/
 @[simp]
 theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal :=
   rfl
 #align ordinal.to_nat_ordinal_symm_eq Ordinal.toNatOrdinal_symm_eq
 
-/- warning: ordinal.to_nat_ordinal_to_ordinal -> Ordinal.toNatOrdinal_toOrdinal is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_to_ordinal Ordinal.toNatOrdinal_toOrdinalₓ'. -/
 @[simp]
 theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
   rfl
 #align ordinal.to_nat_ordinal_to_ordinal Ordinal.toNatOrdinal_toOrdinal
 
-/- warning: ordinal.to_nat_ordinal_zero -> Ordinal.toNatOrdinal_zero is a dubious translation:
-lean 3 declaration is
-  Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))
-but is expected to have type
-  Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_zero Ordinal.toNatOrdinal_zeroₓ'. -/
 @[simp]
 theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
   rfl
 #align ordinal.to_nat_ordinal_zero Ordinal.toNatOrdinal_zero
 
-/- warning: ordinal.to_nat_ordinal_one -> Ordinal.toNatOrdinal_one is a dubious translation:
-lean 3 declaration is
-  Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))
-but is expected to have type
-  Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_one Ordinal.toNatOrdinal_oneₓ'. -/
 @[simp]
 theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
   rfl
 #align ordinal.to_nat_ordinal_one Ordinal.toNatOrdinal_one
 
-/- warning: ordinal.to_nat_ordinal_eq_zero -> Ordinal.toNatOrdinal_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))))
-but is expected to have type
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1})))
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_zero Ordinal.toNatOrdinal_eq_zeroₓ'. -/
 @[simp]
 theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
   Iff.rfl
 #align ordinal.to_nat_ordinal_eq_zero Ordinal.toNatOrdinal_eq_zero
 
-/- warning: ordinal.to_nat_ordinal_eq_one -> Ordinal.toNatOrdinal_eq_one is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))))
-but is expected to have type
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})))
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_oneₓ'. -/
 @[simp]
 theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
   Iff.rfl
 #align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_one
 
-/- warning: ordinal.to_nat_ordinal_max -> Ordinal.toNatOrdinal_max is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_maxₓ'. -/
 @[simp]
 theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOrdinal :=
   rfl
 #align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_max
 
-/- warning: ordinal.to_nat_ordinal_min -> Ordinal.toNatOrdinal_min is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_min Ordinal.toNatOrdinal_minₓ'. -/
 @[simp]
 theorem toNatOrdinal_min :
     (LinearOrder.min a b).toNatOrdinal = LinearOrder.min a.toNatOrdinal b.toNatOrdinal :=
@@ -318,63 +207,27 @@ noncomputable def nadd : Ordinal → Ordinal → Ordinal
 -- mathport name: ordinal.nadd
 scoped[NaturalOps] infixl:65 " ♯ " => Ordinal.nadd
 
-/- warning: ordinal.nadd_def -> Ordinal.nadd_def is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a b) (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (Ordinal.blsub.{u1, u1} a (fun (a' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => Ordinal.nadd.{u1} a' b)) (Ordinal.blsub.{u1, u1} b (fun (b' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => Ordinal.nadd.{u1} a b')))
-but is expected to have type
-  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a b) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (Ordinal.blsub.{u1, u1} a (fun (a' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => Ordinal.nadd.{u1} a' b)) (Ordinal.blsub.{u1, u1} b (fun (b' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => Ordinal.nadd.{u1} a b')))
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_def Ordinal.nadd_defₓ'. -/
 theorem nadd_def (a b : Ordinal) :
     a ♯ b = max (blsub.{u, u} a fun a' h => a' ♯ b) (blsub.{u, u} b fun b' h => a ♯ b') := by
   rw [nadd]
 #align ordinal.nadd_def Ordinal.nadd_def
 
-/- warning: ordinal.lt_nadd_iff -> Ordinal.lt_nadd_iff is a dubious translation:
-lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c)) (Or (Exists.{succ (succ u1)} Ordinal.{u1} (fun (b' : Ordinal.{u1}) => Exists.{0} (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) (fun (H : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b' c)))) (Exists.{succ (succ u1)} Ordinal.{u1} (fun (c' : Ordinal.{u1}) => Exists.{0} (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) (fun (H : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c')))))
-but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c)) (Or (Exists.{succ (succ u1)} Ordinal.{u1} (fun (b' : Ordinal.{u1}) => And (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b' c)))) (Exists.{succ (succ u1)} Ordinal.{u1} (fun (c' : Ordinal.{u1}) => And (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c')))))
-Case conversion may be inaccurate. Consider using '#align ordinal.lt_nadd_iff Ordinal.lt_nadd_iffₓ'. -/
 theorem lt_nadd_iff : a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c' := by rw [nadd_def];
   simp [lt_blsub_iff]
 #align ordinal.lt_nadd_iff Ordinal.lt_nadd_iff
 
-/- warning: ordinal.nadd_le_iff -> Ordinal.nadd_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c) a) (And (forall (b' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b' c) a)) (forall (c' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c') a)))
-but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c) a) (And (forall (b' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b' c) a)) (forall (c' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c') a)))
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_iff Ordinal.nadd_le_iffₓ'. -/
 theorem nadd_le_iff : b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a := by rw [nadd_def];
   simp [blsub_le_iff]
 #align ordinal.nadd_le_iff Ordinal.nadd_le_iff
 
-/- warning: ordinal.nadd_lt_nadd_left -> Ordinal.nadd_lt_nadd_left is a dubious translation:
-lean 3 declaration is
-  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c))
-but is expected to have type
-  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c))
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_lt_nadd_left Ordinal.nadd_lt_nadd_leftₓ'. -/
 theorem nadd_lt_nadd_left (h : b < c) (a) : a ♯ b < a ♯ c :=
   lt_nadd_iff.2 (Or.inr ⟨b, h, le_rfl⟩)
 #align ordinal.nadd_lt_nadd_left Ordinal.nadd_lt_nadd_left
 
-/- warning: ordinal.nadd_lt_nadd_right -> Ordinal.nadd_lt_nadd_right is a dubious translation:
-lean 3 declaration is
-  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a))
-but is expected to have type
-  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a))
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_lt_nadd_right Ordinal.nadd_lt_nadd_rightₓ'. -/
 theorem nadd_lt_nadd_right (h : b < c) (a) : b ♯ a < c ♯ a :=
   lt_nadd_iff.2 (Or.inl ⟨b, h, le_rfl⟩)
 #align ordinal.nadd_lt_nadd_right Ordinal.nadd_lt_nadd_right
 
-/- warning: ordinal.nadd_le_nadd_left -> Ordinal.nadd_le_nadd_left is a dubious translation:
-lean 3 declaration is
-  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c))
-but is expected to have type
-  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c))
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_nadd_left Ordinal.nadd_le_nadd_leftₓ'. -/
 theorem nadd_le_nadd_left (h : b ≤ c) (a) : a ♯ b ≤ a ♯ c :=
   by
   rcases lt_or_eq_of_le h with (h | rfl)
@@ -382,12 +235,6 @@ theorem nadd_le_nadd_left (h : b ≤ c) (a) : a ♯ b ≤ a ♯ c :=
   · exact le_rfl
 #align ordinal.nadd_le_nadd_left Ordinal.nadd_le_nadd_left
 
-/- warning: ordinal.nadd_le_nadd_right -> Ordinal.nadd_le_nadd_right is a dubious translation:
-lean 3 declaration is
-  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a))
-but is expected to have type
-  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a))
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_nadd_right Ordinal.nadd_le_nadd_rightₓ'. -/
 theorem nadd_le_nadd_right (h : b ≤ c) (a) : b ♯ a ≤ c ♯ a :=
   by
   rcases lt_or_eq_of_le h with (h | rfl)
@@ -406,12 +253,6 @@ theorem nadd_comm : ∀ a b, a ♯ b = b ♯ a
 #align ordinal.nadd_comm Ordinal.nadd_comm
 -/
 
-/- warning: ordinal.blsub_nadd_of_mono -> Ordinal.blsub_nadd_of_mono is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}) {f : forall (c : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c (Ordinal.nadd.{u1} a b)) -> Ordinal.{max u1 u2}}, (forall {i : Ordinal.{u1}} {j : Ordinal.{u1}} (hi : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i (Ordinal.nadd.{u1} a b)) (hj : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) j (Ordinal.nadd.{u1} a b)), (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i j) -> (LE.le.{succ (max u1 u2)} Ordinal.{max u1 u2} (Preorder.toHasLe.{succ (max u1 u2)} Ordinal.{max u1 u2} (PartialOrder.toPreorder.{succ (max u1 u2)} Ordinal.{max u1 u2} Ordinal.partialOrder.{max u1 u2})) (f i hi) (f j hj))) -> (Eq.{succ (succ (max u1 u2))} Ordinal.{max u1 u2} (Ordinal.blsub.{u1, u2} (Ordinal.nadd.{u1} a b) f) (LinearOrder.max.{succ (max u1 u2)} Ordinal.{max u1 u2} Ordinal.linearOrder.{max u1 u2} (Ordinal.blsub.{u1, u2} a (fun (a' : Ordinal.{u1}) (ha' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => f (Ordinal.nadd.{u1} a' b) (Ordinal.nadd_lt_nadd_right.{u1} a' a ha' b))) (Ordinal.blsub.{u1, u2} b (fun (b' : Ordinal.{u1}) (hb' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => f (Ordinal.nadd.{u1} a b') (Ordinal.nadd_lt_nadd_left.{u1} b' b hb' a)))))
-but is expected to have type
-  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}) {f : forall (c : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c (Ordinal.nadd.{u1} a b)) -> Ordinal.{max u1 u2}}, (forall {i : Ordinal.{u1}} {j : Ordinal.{u1}} (hi : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i (Ordinal.nadd.{u1} a b)) (hj : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) j (Ordinal.nadd.{u1} a b)), (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i j) -> (LE.le.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} (Preorder.toLE.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} (PartialOrder.toPreorder.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} Ordinal.partialOrder.{max u1 u2})) (f i hi) (f j hj))) -> (Eq.{max (succ (succ u1)) (succ (succ u2))} Ordinal.{max u1 u2} (Ordinal.blsub.{u1, u2} (Ordinal.nadd.{u1} a b) f) (Max.max.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} (LinearOrder.toMax.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} Ordinal.linearOrder.{max u1 u2}) (Ordinal.blsub.{u1, u2} a (fun (a' : Ordinal.{u1}) (ha' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => f (Ordinal.nadd.{u1} a' b) (Ordinal.nadd_lt_nadd_right.{u1} a' a ha' b))) (Ordinal.blsub.{u1, u2} b (fun (b' : Ordinal.{u1}) (hb' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => f (Ordinal.nadd.{u1} a b') (Ordinal.nadd_lt_nadd_left.{u1} b' b hb' a)))))
-Case conversion may be inaccurate. Consider using '#align ordinal.blsub_nadd_of_mono Ordinal.blsub_nadd_of_monoₓ'. -/
 theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
     (hf : ∀ {i j} (hi hj), i ≤ j → f i hi ≤ f j hj) :
     blsub _ f =
@@ -458,12 +299,6 @@ theorem zero_nadd : 0 ♯ a = a := by rw [nadd_comm, nadd_zero]
 #align ordinal.zero_nadd Ordinal.zero_nadd
 -/
 
-/- warning: ordinal.nadd_one -> Ordinal.nadd_one is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (Order.succ.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}) Ordinal.succOrder.{u1} a)
-but is expected to have type
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (Order.succ.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}) Ordinal.succOrder.{u1} a)
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_one Ordinal.nadd_oneₓ'. -/
 @[simp]
 theorem nadd_one : a ♯ 1 = succ a :=
   by
@@ -473,12 +308,6 @@ theorem nadd_one : a ♯ 1 = succ a :=
   rwa [IH i hi, succ_lt_succ_iff]
 #align ordinal.nadd_one Ordinal.nadd_one
 
-/- warning: ordinal.one_nadd -> Ordinal.one_nadd is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))) a) (Order.succ.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}) Ordinal.succOrder.{u1} a)
-but is expected to have type
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})) a) (Order.succ.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}) Ordinal.succOrder.{u1} a)
-Case conversion may be inaccurate. Consider using '#align ordinal.one_nadd Ordinal.one_naddₓ'. -/
 @[simp]
 theorem one_nadd : 1 ♯ a = succ a := by rw [nadd_comm, nadd_one]
 #align ordinal.one_nadd Ordinal.one_nadd
@@ -509,12 +338,6 @@ theorem nat_nadd (n : ℕ) : ↑n ♯ a = a + n := by rw [nadd_comm, nadd_nat]
 #align ordinal.nat_nadd Ordinal.nat_nadd
 -/
 
-/- warning: ordinal.add_le_nadd -> Ordinal.add_le_nadd is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.hasAdd.{u1}) a b) (Ordinal.nadd.{u1} a b)
-but is expected to have type
-  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.add.{u1}) a b) (Ordinal.nadd.{u1} a b)
-Case conversion may be inaccurate. Consider using '#align ordinal.add_le_nadd Ordinal.add_le_naddₓ'. -/
 theorem add_le_nadd : a + b ≤ a ♯ b := by
   apply b.limit_rec_on
   · simp
@@ -534,32 +357,14 @@ namespace NatOrdinal
 instance : Add NatOrdinal :=
   ⟨nadd⟩
 
-/- warning: nat_ordinal.add_covariant_class_lt -> NatOrdinal.add_covariantClass_lt is a dubious translation:
-lean 3 declaration is
-  CovariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.hasAdd.{u1})) (LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toHasLt.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
-but is expected to have type
-  CovariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3701 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3703 : NatOrdinal.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.instAddNatOrdinal.{u1}) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3701 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3703) (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3716 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3718 : NatOrdinal.{u1}) => LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toLT.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3716 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3718)
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_covariant_class_lt NatOrdinal.add_covariantClass_ltₓ'. -/
 instance add_covariantClass_lt : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· < ·) :=
   ⟨fun a b c h => nadd_lt_nadd_left h a⟩
 #align nat_ordinal.add_covariant_class_lt NatOrdinal.add_covariantClass_lt
 
-/- warning: nat_ordinal.add_covariant_class_le -> NatOrdinal.add_covariantClass_le is a dubious translation:
-lean 3 declaration is
-  CovariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.hasAdd.{u1})) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
-but is expected to have type
-  CovariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3749 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3751 : NatOrdinal.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.instAddNatOrdinal.{u1}) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3749 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3751) (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3764 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3766 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3764 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3766)
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_covariant_class_le NatOrdinal.add_covariantClass_leₓ'. -/
 instance add_covariantClass_le : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => nadd_le_nadd_left h a⟩
 #align nat_ordinal.add_covariant_class_le NatOrdinal.add_covariantClass_le
 
-/- warning: nat_ordinal.add_contravariant_class_le -> NatOrdinal.add_contravariantClass_le is a dubious translation:
-lean 3 declaration is
-  ContravariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.hasAdd.{u1})) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
-but is expected to have type
-  ContravariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3797 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3799 : NatOrdinal.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.instAddNatOrdinal.{u1}) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3797 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3799) (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3812 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3814 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3812 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3814)
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_leₓ'. -/
 instance add_contravariantClass_le :
     ContravariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => by by_contra' h'; exact h.not_lt (add_lt_add_left h' a)⟩
@@ -579,23 +384,11 @@ instance : OrderedCancelAddCommMonoid NatOrdinal :=
 instance : AddMonoidWithOne NatOrdinal :=
   AddMonoidWithOne.unary
 
-/- warning: nat_ordinal.add_one_eq_succ -> NatOrdinal.add_one_eq_succ is a dubious translation:
-lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.hasAdd.{u1}) a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (OrderedCancelAddCommMonoid.toPartialOrder.{succ u1} NatOrdinal.{u1} NatOrdinal.orderedCancelAddCommMonoid.{u1})) NatOrdinal.succOrder.{u1} a)
-but is expected to have type
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.instAddNatOrdinal.{u1}) a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (OrderedCancelAddCommMonoid.toPartialOrder.{succ u1} NatOrdinal.{u1} NatOrdinal.instOrderedCancelAddCommMonoidNatOrdinal.{u1})) NatOrdinal.succOrder.{u1} a)
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_one_eq_succ NatOrdinal.add_one_eq_succₓ'. -/
 @[simp]
 theorem add_one_eq_succ : ∀ a : NatOrdinal, a + 1 = succ a :=
   nadd_one
 #align nat_ordinal.add_one_eq_succ NatOrdinal.add_one_eq_succ
 
-/- warning: nat_ordinal.to_ordinal_cast_nat -> NatOrdinal.toOrdinal_cast_nat is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)
-but is expected to have type
-  forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)
-Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_cast_nat NatOrdinal.toOrdinal_cast_natₓ'. -/
 @[simp]
 theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n :=
   by
@@ -614,92 +407,38 @@ open NaturalOps
 
 namespace Ordinal
 
-/- warning: ordinal.to_nat_ordinal_cast_nat -> Ordinal.toNatOrdinal_cast_nat is a dubious translation:
-lean 3 declaration is
-  forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)
-but is expected to have type
-  forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)
-Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_natₓ'. -/
 @[simp]
 theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n := by rw [← to_ordinal_cast_nat n]; rfl
 #align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_nat
 
-/- warning: ordinal.lt_of_nadd_lt_nadd_left -> Ordinal.lt_of_nadd_lt_nadd_left is a dubious translation:
-lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-Case conversion may be inaccurate. Consider using '#align ordinal.lt_of_nadd_lt_nadd_left Ordinal.lt_of_nadd_lt_nadd_leftₓ'. -/
 theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c :=
   @lt_of_add_lt_add_left NatOrdinal _ _ _
 #align ordinal.lt_of_nadd_lt_nadd_left Ordinal.lt_of_nadd_lt_nadd_left
 
-/- warning: ordinal.lt_of_nadd_lt_nadd_right -> Ordinal.lt_of_nadd_lt_nadd_right is a dubious translation:
-lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-Case conversion may be inaccurate. Consider using '#align ordinal.lt_of_nadd_lt_nadd_right Ordinal.lt_of_nadd_lt_nadd_rightₓ'. -/
 theorem lt_of_nadd_lt_nadd_right : ∀ {a b c}, b ♯ a < c ♯ a → b < c :=
   @lt_of_add_lt_add_right NatOrdinal _ _ _
 #align ordinal.lt_of_nadd_lt_nadd_right Ordinal.lt_of_nadd_lt_nadd_right
 
-/- warning: ordinal.le_of_nadd_le_nadd_left -> Ordinal.le_of_nadd_le_nadd_left is a dubious translation:
-lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) -> (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) -> (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-Case conversion may be inaccurate. Consider using '#align ordinal.le_of_nadd_le_nadd_left Ordinal.le_of_nadd_le_nadd_leftₓ'. -/
 theorem le_of_nadd_le_nadd_left : ∀ {a b c}, a ♯ b ≤ a ♯ c → b ≤ c :=
   @le_of_add_le_add_left NatOrdinal _ _ _
 #align ordinal.le_of_nadd_le_nadd_left Ordinal.le_of_nadd_le_nadd_left
 
-/- warning: ordinal.le_of_nadd_le_nadd_right -> Ordinal.le_of_nadd_le_nadd_right is a dubious translation:
-lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) -> (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) -> (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-Case conversion may be inaccurate. Consider using '#align ordinal.le_of_nadd_le_nadd_right Ordinal.le_of_nadd_le_nadd_rightₓ'. -/
 theorem le_of_nadd_le_nadd_right : ∀ {a b c}, b ♯ a ≤ c ♯ a → b ≤ c :=
   @le_of_add_le_add_right NatOrdinal _ _ _
 #align ordinal.le_of_nadd_le_nadd_right Ordinal.le_of_nadd_le_nadd_right
 
-/- warning: ordinal.nadd_lt_nadd_iff_left -> Ordinal.nadd_lt_nadd_iff_left is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-but is expected to have type
-  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_lt_nadd_iff_left Ordinal.nadd_lt_nadd_iff_leftₓ'. -/
 theorem nadd_lt_nadd_iff_left : ∀ (a) {b c}, a ♯ b < a ♯ c ↔ b < c :=
   @add_lt_add_iff_left NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd_iff_left Ordinal.nadd_lt_nadd_iff_left
 
-/- warning: ordinal.nadd_lt_nadd_iff_right -> Ordinal.nadd_lt_nadd_iff_right is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-but is expected to have type
-  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_lt_nadd_iff_right Ordinal.nadd_lt_nadd_iff_rightₓ'. -/
 theorem nadd_lt_nadd_iff_right : ∀ (a) {b c}, b ♯ a < c ♯ a ↔ b < c :=
   @add_lt_add_iff_right NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd_iff_right Ordinal.nadd_lt_nadd_iff_right
 
-/- warning: ordinal.nadd_le_nadd_iff_left -> Ordinal.nadd_le_nadd_iff_left is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-but is expected to have type
-  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_nadd_iff_left Ordinal.nadd_le_nadd_iff_leftₓ'. -/
 theorem nadd_le_nadd_iff_left : ∀ (a) {b c}, a ♯ b ≤ a ♯ c ↔ b ≤ c :=
   @add_le_add_iff_left NatOrdinal _ _ _ _
 #align ordinal.nadd_le_nadd_iff_left Ordinal.nadd_le_nadd_iff_left
 
-/- warning: ordinal.nadd_le_nadd_iff_right -> Ordinal.nadd_le_nadd_iff_right is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-but is expected to have type
-  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
-Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_nadd_iff_right Ordinal.nadd_le_nadd_iff_rightₓ'. -/
 theorem nadd_le_nadd_iff_right : ∀ (a) {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c :=
   @add_le_add_iff_right NatOrdinal _ _ _ _
 #align ordinal.nadd_le_nadd_iff_right Ordinal.nadd_le_nadd_iff_right

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -335,9 +335,7 @@ lean 3 declaration is
 but is expected to have type
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c)) (Or (Exists.{succ (succ u1)} Ordinal.{u1} (fun (b' : Ordinal.{u1}) => And (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b' c)))) (Exists.{succ (succ u1)} Ordinal.{u1} (fun (c' : Ordinal.{u1}) => And (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c')))))
 Case conversion may be inaccurate. Consider using '#align ordinal.lt_nadd_iff Ordinal.lt_nadd_iffₓ'. -/
-theorem lt_nadd_iff : a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c' :=
-  by
-  rw [nadd_def]
+theorem lt_nadd_iff : a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c' := by rw [nadd_def];
   simp [lt_blsub_iff]
 #align ordinal.lt_nadd_iff Ordinal.lt_nadd_iff
 
@@ -347,9 +345,7 @@ lean 3 declaration is
 but is expected to have type
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c) a) (And (forall (b' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b' c) a)) (forall (c' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c') a)))
 Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_iff Ordinal.nadd_le_iffₓ'. -/
-theorem nadd_le_iff : b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a :=
-  by
-  rw [nadd_def]
+theorem nadd_le_iff : b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a := by rw [nadd_def];
   simp [blsub_le_iff]
 #align ordinal.nadd_le_iff Ordinal.nadd_le_iff
 
@@ -566,9 +562,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_leₓ'. -/
 instance add_contravariantClass_le :
     ContravariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
-  ⟨fun a b c h => by
-    by_contra' h'
-    exact h.not_lt (add_lt_add_left h' a)⟩
+  ⟨fun a b c h => by by_contra' h'; exact h.not_lt (add_lt_add_left h' a)⟩
 #align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_le
 
 instance : OrderedCancelAddCommMonoid NatOrdinal :=
@@ -627,10 +621,7 @@ but is expected to have type
   forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_natₓ'. -/
 @[simp]
-theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n :=
-  by
-  rw [← to_ordinal_cast_nat n]
-  rfl
+theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n := by rw [← to_ordinal_cast_nat n]; rfl
 #align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_nat
 
 /- warning: ordinal.lt_of_nadd_lt_nadd_left -> Ordinal.lt_of_nadd_lt_nadd_left is a dubious translation:

bump to nightly-2023-05-28-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6c6011cf

Diff

@@ -103,10 +103,7 @@ theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
 #align nat_ordinal.to_ordinal_symm_eq NatOrdinal.toOrdinal_symm_eq
 
 /- warning: nat_ordinal.to_ordinal_to_nat_ordinal -> NatOrdinal.toOrdinal_toNatOrdinal is a dubious translation:
-lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a)) a
-but is expected to have type
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a)) a
+<too large>
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinalₓ'. -/
 @[simp]
 theorem toOrdinal_toNatOrdinal (a : NatOrdinal) : a.toOrdinal.toNatOrdinal = a :=
@@ -174,10 +171,7 @@ theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
 #align nat_ordinal.to_ordinal_eq_one NatOrdinal.toOrdinal_eq_one
 
 /- warning: nat_ordinal.to_ordinal_max -> NatOrdinal.toOrdinal_max is a dubious translation:
-lean 3 declaration is
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
-but is expected to have type
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} b))
+<too large>
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_max NatOrdinal.toOrdinal_maxₓ'. -/
 @[simp]
 theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
@@ -185,10 +179,7 @@ theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
 #align nat_ordinal.to_ordinal_max NatOrdinal.toOrdinal_max
 
 /- warning: nat_ordinal.to_ordinal_min -> NatOrdinal.toOrdinal_min is a dubious translation:
-lean 3 declaration is
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
-but is expected to have type
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (Min.min.{succ u1} NatOrdinal.{u1} (LinearOrder.toMin.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} b))
+<too large>
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_min NatOrdinal.toOrdinal_minₓ'. -/
 @[simp]
 theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
@@ -196,10 +187,7 @@ theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
 #align nat_ordinal.to_ordinal_min NatOrdinal.toOrdinal_min
 
 /- warning: nat_ordinal.succ_def -> NatOrdinal.succ_def is a dubious translation:
-lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))) NatOrdinal.succOrder.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.hasAdd.{u1}) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))))
-but is expected to have type
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) NatOrdinal.succOrder.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.add.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.succ_def NatOrdinal.succ_defₓ'. -/
 theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
   rfl
@@ -245,10 +233,7 @@ theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal :=
 #align ordinal.to_nat_ordinal_symm_eq Ordinal.toNatOrdinal_symm_eq
 
 /- warning: ordinal.to_nat_ordinal_to_ordinal -> Ordinal.toNatOrdinal_toOrdinal is a dubious translation:
-lean 3 declaration is
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) a
-but is expected to have type
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a)) a
+<too large>
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_to_ordinal Ordinal.toNatOrdinal_toOrdinalₓ'. -/
 @[simp]
 theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
@@ -300,10 +285,7 @@ theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
 #align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_one
 
 /- warning: ordinal.to_nat_ordinal_max -> Ordinal.toNatOrdinal_max is a dubious translation:
-lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
-but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} b))
+<too large>
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_maxₓ'. -/
 @[simp]
 theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOrdinal :=
@@ -311,10 +293,7 @@ theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOr
 #align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_max
 
 /- warning: ordinal.to_nat_ordinal_min -> Ordinal.toNatOrdinal_min is a dubious translation:
-lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
-but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} b))
+<too large>
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_min Ordinal.toNatOrdinal_minₓ'. -/
 @[simp]
 theorem toNatOrdinal_min :

bump to nightly-2023-05-19-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

a31df521

Diff

@@ -106,7 +106,7 @@ theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a)) a
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a)) a
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a)) a
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinalₓ'. -/
 @[simp]
 theorem toOrdinal_toNatOrdinal (a : NatOrdinal) : a.toOrdinal.toNatOrdinal = a :=
@@ -133,7 +133,7 @@ instance : IsWellOrder NatOrdinal (· < ·) :=
 lean 3 declaration is
   Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))
+  Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_zero NatOrdinal.toOrdinal_zeroₓ'. -/
 @[simp]
 theorem toOrdinal_zero : toOrdinal 0 = 0 :=
@@ -144,7 +144,7 @@ theorem toOrdinal_zero : toOrdinal 0 = 0 :=
 lean 3 declaration is
   Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))
+  Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_one NatOrdinal.toOrdinal_oneₓ'. -/
 @[simp]
 theorem toOrdinal_one : toOrdinal 1 = 1 :=
@@ -155,7 +155,7 @@ theorem toOrdinal_one : toOrdinal 1 = 1 :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1}))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1})))
+  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1})))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_zero NatOrdinal.toOrdinal_eq_zeroₓ'. -/
 @[simp]
 theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
@@ -166,7 +166,7 @@ theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1}))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1})))
+  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1})))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_one NatOrdinal.toOrdinal_eq_oneₓ'. -/
 @[simp]
 theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
@@ -177,7 +177,7 @@ theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
 lean 3 declaration is
   forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
 but is expected to have type
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} b))
+  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_max NatOrdinal.toOrdinal_maxₓ'. -/
 @[simp]
 theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
@@ -188,7 +188,7 @@ theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
 lean 3 declaration is
   forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
 but is expected to have type
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Min.min.{succ u1} NatOrdinal.{u1} (LinearOrder.toMin.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} b))
+  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (Min.min.{succ u1} NatOrdinal.{u1} (LinearOrder.toMin.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_min NatOrdinal.toOrdinal_minₓ'. -/
 @[simp]
 theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
@@ -199,7 +199,7 @@ theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))) NatOrdinal.succOrder.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.hasAdd.{u1}) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) NatOrdinal.succOrder.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.add.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))))
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) NatOrdinal.succOrder.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.add.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.succ_def NatOrdinal.succ_defₓ'. -/
 theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
   rfl
@@ -209,7 +209,7 @@ theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
 lean 3 declaration is
   forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
 but is expected to have type
-  forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
+  forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.rec NatOrdinal.recₓ'. -/
 /-- A recursor for `nat_ordinal`. Use as `induction x using nat_ordinal.rec`. -/
 protected def rec {β : NatOrdinal → Sort _} (h : ∀ a, β (toNatOrdinal a)) : ∀ a, β a := fun a =>
@@ -248,7 +248,7 @@ theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal :=
 lean 3 declaration is
   forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) a
 but is expected to have type
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a)) a
+  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a)) a
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_to_ordinal Ordinal.toNatOrdinal_toOrdinalₓ'. -/
 @[simp]
 theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
@@ -259,7 +259,7 @@ theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
 lean 3 declaration is
   Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))
+  Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_zero Ordinal.toNatOrdinal_zeroₓ'. -/
 @[simp]
 theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
@@ -270,7 +270,7 @@ theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
 lean 3 declaration is
   Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))
+  Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_one Ordinal.toNatOrdinal_oneₓ'. -/
 @[simp]
 theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
@@ -281,7 +281,7 @@ theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
 lean 3 declaration is
   forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))))
 but is expected to have type
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1})))
+  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1})))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_zero Ordinal.toNatOrdinal_eq_zeroₓ'. -/
 @[simp]
 theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
@@ -292,7 +292,7 @@ theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
 lean 3 declaration is
   forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))))
 but is expected to have type
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})))
+  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_oneₓ'. -/
 @[simp]
 theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
@@ -303,7 +303,7 @@ theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
 lean 3 declaration is
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
 but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} b))
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_maxₓ'. -/
 @[simp]
 theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOrdinal :=
@@ -314,7 +314,7 @@ theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOr
 lean 3 declaration is
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
 but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} b))
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_min Ordinal.toNatOrdinal_minₓ'. -/
 @[simp]
 theorem toNatOrdinal_min :
@@ -621,7 +621,7 @@ theorem add_one_eq_succ : ∀ a : NatOrdinal, a + 1 = succ a :=
 lean 3 declaration is
   forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)
 but is expected to have type
-  forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)
+  forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) NatOrdinal.toOrdinal.{u1} (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_cast_nat NatOrdinal.toOrdinal_cast_natₓ'. -/
 @[simp]
 theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n :=
@@ -645,7 +645,7 @@ namespace Ordinal
 lean 3 declaration is
   forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)
 but is expected to have type
-  forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)
+  forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) Ordinal.toNatOrdinal.{u1} (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_natₓ'. -/
 @[simp]
 theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n :=

bump to nightly-2023-05-16-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

9cb92e8c

Diff

@@ -61,21 +61,29 @@ def NatOrdinal : Type _ :=
 #align nat_ordinal NatOrdinal
 -/
 
-#print Ordinal.toNatOrdinal /-
+/- warning: ordinal.to_nat_ordinal -> Ordinal.toNatOrdinal is a dubious translation:
+lean 3 declaration is
+  OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))
+but is expected to have type
+  OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
+Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal Ordinal.toNatOrdinalₓ'. -/
 /-- The identity function between `ordinal` and `nat_ordinal`. -/
 @[match_pattern]
 def Ordinal.toNatOrdinal : Ordinal ≃o NatOrdinal :=
   OrderIso.refl _
 #align ordinal.to_nat_ordinal Ordinal.toNatOrdinal
--/
 
-#print NatOrdinal.toOrdinal /-
+/- warning: nat_ordinal.to_ordinal -> NatOrdinal.toOrdinal is a dubious translation:
+lean 3 declaration is
+  OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))
+but is expected to have type
+  OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))
+Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal NatOrdinal.toOrdinalₓ'. -/
 /-- The identity function between `nat_ordinal` and `ordinal`. -/
 @[match_pattern]
 def NatOrdinal.toOrdinal : NatOrdinal ≃o Ordinal :=
   OrderIso.refl _
 #align nat_ordinal.to_ordinal NatOrdinal.toOrdinal
--/
 
 open Ordinal
 
@@ -83,16 +91,20 @@ namespace NatOrdinal
 
 variable {a b c : NatOrdinal.{u}}
 
-#print NatOrdinal.toOrdinal_symm_eq /-
+/- warning: nat_ordinal.to_ordinal_symm_eq -> NatOrdinal.toOrdinal_symm_eq is a dubious translation:
+lean 3 declaration is
+  Eq.{succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (OrderIso.symm.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) NatOrdinal.toOrdinal.{u1}) Ordinal.toNatOrdinal.{u1}
+but is expected to have type
+  Eq.{succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) (OrderIso.symm.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) NatOrdinal.toOrdinal.{u1}) Ordinal.toNatOrdinal.{u1}
+Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_symm_eq NatOrdinal.toOrdinal_symm_eqₓ'. -/
 @[simp]
 theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
   rfl
 #align nat_ordinal.to_ordinal_symm_eq NatOrdinal.toOrdinal_symm_eq
--/
 
 /- warning: nat_ordinal.to_ordinal_to_nat_ordinal -> NatOrdinal.toOrdinal_toNatOrdinal is a dubious translation:
 lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a)) a
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a)) a
 but is expected to have type
   forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a)) a
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinalₓ'. -/
@@ -101,11 +113,15 @@ theorem toOrdinal_toNatOrdinal (a : NatOrdinal) : a.toOrdinal.toNatOrdinal = a :
   rfl
 #align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinal
 
-#print NatOrdinal.lt_wf /-
+/- warning: nat_ordinal.lt_wf -> NatOrdinal.lt_wf is a dubious translation:
+lean 3 declaration is
+  WellFounded.{succ (succ u1)} NatOrdinal.{u1} (LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toHasLt.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
+but is expected to have type
+  WellFounded.{succ (succ u1)} NatOrdinal.{u1} (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.227 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.229 : NatOrdinal.{u1}) => LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toLT.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.227 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.229)
+Case conversion may be inaccurate. Consider using '#align nat_ordinal.lt_wf NatOrdinal.lt_wfₓ'. -/
 theorem lt_wf : @WellFounded NatOrdinal (· < ·) :=
   Ordinal.lt_wf
 #align nat_ordinal.lt_wf NatOrdinal.lt_wf
--/
 
 instance : WellFoundedLT NatOrdinal :=
   Ordinal.wellFoundedLT
@@ -115,7 +131,7 @@ instance : IsWellOrder NatOrdinal (· < ·) :=
 
 /- warning: nat_ordinal.to_ordinal_zero -> NatOrdinal.toOrdinal_zero is a dubious translation:
 lean 3 declaration is
-  Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))
+  Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))
 but is expected to have type
   Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_zero NatOrdinal.toOrdinal_zeroₓ'. -/
@@ -126,7 +142,7 @@ theorem toOrdinal_zero : toOrdinal 0 = 0 :=
 
 /- warning: nat_ordinal.to_ordinal_one -> NatOrdinal.toOrdinal_one is a dubious translation:
 lean 3 declaration is
-  Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))
+  Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))
 but is expected to have type
   Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_one NatOrdinal.toOrdinal_oneₓ'. -/
@@ -137,7 +153,7 @@ theorem toOrdinal_one : toOrdinal 1 = 1 :=
 
 /- warning: nat_ordinal.to_ordinal_eq_zero -> NatOrdinal.toOrdinal_eq_zero is a dubious translation:
 lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1}))))
+  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1}))))
 but is expected to have type
   forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1})))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_zero NatOrdinal.toOrdinal_eq_zeroₓ'. -/
@@ -148,7 +164,7 @@ theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
 
 /- warning: nat_ordinal.to_ordinal_eq_one -> NatOrdinal.toOrdinal_eq_one is a dubious translation:
 lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1}))))
+  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1}))))
 but is expected to have type
   forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1})))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_one NatOrdinal.toOrdinal_eq_oneₓ'. -/
@@ -159,7 +175,7 @@ theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
 
 /- warning: nat_ordinal.to_ordinal_max -> NatOrdinal.toOrdinal_max is a dubious translation:
 lean 3 declaration is
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
+  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
 but is expected to have type
   forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_max NatOrdinal.toOrdinal_maxₓ'. -/
@@ -170,7 +186,7 @@ theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
 
 /- warning: nat_ordinal.to_ordinal_min -> NatOrdinal.toOrdinal_min is a dubious translation:
 lean 3 declaration is
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
+  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
 but is expected to have type
   forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Min.min.{succ u1} NatOrdinal.{u1} (LinearOrder.toMin.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_min NatOrdinal.toOrdinal_minₓ'. -/
@@ -181,7 +197,7 @@ theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
 
 /- warning: nat_ordinal.succ_def -> NatOrdinal.succ_def is a dubious translation:
 lean 3 declaration is
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))) NatOrdinal.succOrder.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.hasAdd.{u1}) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))))
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))) NatOrdinal.succOrder.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.hasAdd.{u1}) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))))
 but is expected to have type
   forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) NatOrdinal.succOrder.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.add.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.succ_def NatOrdinal.succ_defₓ'. -/
@@ -191,7 +207,7 @@ theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
 
 /- warning: nat_ordinal.rec -> NatOrdinal.rec is a dubious translation:
 lean 3 declaration is
-  forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
+  forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
 but is expected to have type
   forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.rec NatOrdinal.recₓ'. -/
@@ -200,12 +216,16 @@ protected def rec {β : NatOrdinal → Sort _} (h : ∀ a, β (toNatOrdinal a))
   h a.toOrdinal
 #align nat_ordinal.rec NatOrdinal.rec
 
-#print NatOrdinal.induction /-
+/- warning: nat_ordinal.induction -> NatOrdinal.induction is a dubious translation:
+lean 3 declaration is
+  forall {p : NatOrdinal.{u1} -> Prop} (i : NatOrdinal.{u1}), (forall (j : NatOrdinal.{u1}), (forall (k : NatOrdinal.{u1}), (LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toHasLt.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) k j) -> (p k)) -> (p j)) -> (p i)
+but is expected to have type
+  forall {p : NatOrdinal.{u1} -> Prop} (i : NatOrdinal.{u1}), (forall (j : NatOrdinal.{u1}), (forall (k : NatOrdinal.{u1}), (LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toLT.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) k j) -> (p k)) -> (p j)) -> (p i)
+Case conversion may be inaccurate. Consider using '#align nat_ordinal.induction NatOrdinal.inductionₓ'. -/
 /-- `ordinal.induction` but for `nat_ordinal`. -/
 theorem induction {p : NatOrdinal → Prop} : ∀ (i) (h : ∀ j, (∀ k, k < j → p k) → p j), p i :=
   Ordinal.induction
 #align nat_ordinal.induction NatOrdinal.induction
--/
 
 end NatOrdinal
 
@@ -213,16 +233,20 @@ namespace Ordinal
 
 variable {a b c : Ordinal.{u}}
 
-#print Ordinal.toNatOrdinal_symm_eq /-
+/- warning: ordinal.to_nat_ordinal_symm_eq -> Ordinal.toNatOrdinal_symm_eq is a dubious translation:
+lean 3 declaration is
+  Eq.{succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (OrderIso.symm.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) Ordinal.toNatOrdinal.{u1}) NatOrdinal.toOrdinal.{u1}
+but is expected to have type
+  Eq.{succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (OrderIso.symm.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) Ordinal.toNatOrdinal.{u1}) NatOrdinal.toOrdinal.{u1}
+Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_symm_eq Ordinal.toNatOrdinal_symm_eqₓ'. -/
 @[simp]
 theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal :=
   rfl
 #align ordinal.to_nat_ordinal_symm_eq Ordinal.toNatOrdinal_symm_eq
--/
 
 /- warning: ordinal.to_nat_ordinal_to_ordinal -> Ordinal.toNatOrdinal_toOrdinal is a dubious translation:
 lean 3 declaration is
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) a
+  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) a
 but is expected to have type
   forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a)) a
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_to_ordinal Ordinal.toNatOrdinal_toOrdinalₓ'. -/
@@ -233,7 +257,7 @@ theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
 
 /- warning: ordinal.to_nat_ordinal_zero -> Ordinal.toNatOrdinal_zero is a dubious translation:
 lean 3 declaration is
-  Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))
+  Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))
 but is expected to have type
   Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_zero Ordinal.toNatOrdinal_zeroₓ'. -/
@@ -244,7 +268,7 @@ theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
 
 /- warning: ordinal.to_nat_ordinal_one -> Ordinal.toNatOrdinal_one is a dubious translation:
 lean 3 declaration is
-  Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))
+  Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))
 but is expected to have type
   Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_one Ordinal.toNatOrdinal_oneₓ'. -/
@@ -255,7 +279,7 @@ theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
 
 /- warning: ordinal.to_nat_ordinal_eq_zero -> Ordinal.toNatOrdinal_eq_zero is a dubious translation:
 lean 3 declaration is
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))))
+  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))))
 but is expected to have type
   forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1})))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_zero Ordinal.toNatOrdinal_eq_zeroₓ'. -/
@@ -266,7 +290,7 @@ theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
 
 /- warning: ordinal.to_nat_ordinal_eq_one -> Ordinal.toNatOrdinal_eq_one is a dubious translation:
 lean 3 declaration is
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))))
+  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))))
 but is expected to have type
   forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_oneₓ'. -/
@@ -277,7 +301,7 @@ theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
 
 /- warning: ordinal.to_nat_ordinal_max -> Ordinal.toNatOrdinal_max is a dubious translation:
 lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
 but is expected to have type
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_maxₓ'. -/
@@ -288,7 +312,7 @@ theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOr
 
 /- warning: ordinal.to_nat_ordinal_min -> Ordinal.toNatOrdinal_min is a dubious translation:
 lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
 but is expected to have type
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_min Ordinal.toNatOrdinal_minₓ'. -/
@@ -317,7 +341,7 @@ scoped[NaturalOps] infixl:65 " ♯ " => Ordinal.nadd
 
 /- warning: ordinal.nadd_def -> Ordinal.nadd_def is a dubious translation:
 lean 3 declaration is
-  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a b) (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (Ordinal.blsub.{u1, u1} a (fun (a' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => Ordinal.nadd.{u1} a' b)) (Ordinal.blsub.{u1, u1} b (fun (b' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => Ordinal.nadd.{u1} a b')))
+  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a b) (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (Ordinal.blsub.{u1, u1} a (fun (a' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => Ordinal.nadd.{u1} a' b)) (Ordinal.blsub.{u1, u1} b (fun (b' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => Ordinal.nadd.{u1} a b')))
 but is expected to have type
   forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a b) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (Ordinal.blsub.{u1, u1} a (fun (a' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => Ordinal.nadd.{u1} a' b)) (Ordinal.blsub.{u1, u1} b (fun (b' : Ordinal.{u1}) (h : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => Ordinal.nadd.{u1} a b')))
 Case conversion may be inaccurate. Consider using '#align ordinal.nadd_def Ordinal.nadd_defₓ'. -/
@@ -328,7 +352,7 @@ theorem nadd_def (a b : Ordinal) :
 
 /- warning: ordinal.lt_nadd_iff -> Ordinal.lt_nadd_iff is a dubious translation:
 lean 3 declaration is
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c)) (Or (Exists.{succ (succ u1)} Ordinal.{u1} (fun (b' : Ordinal.{u1}) => Exists.{0} (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) (fun (H : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b' c)))) (Exists.{succ (succ u1)} Ordinal.{u1} (fun (c' : Ordinal.{u1}) => Exists.{0} (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) (fun (H : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c')))))
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c)) (Or (Exists.{succ (succ u1)} Ordinal.{u1} (fun (b' : Ordinal.{u1}) => Exists.{0} (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) (fun (H : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b' c)))) (Exists.{succ (succ u1)} Ordinal.{u1} (fun (c' : Ordinal.{u1}) => Exists.{0} (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) (fun (H : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c')))))
 but is expected to have type
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c)) (Or (Exists.{succ (succ u1)} Ordinal.{u1} (fun (b' : Ordinal.{u1}) => And (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b' c)))) (Exists.{succ (succ u1)} Ordinal.{u1} (fun (c' : Ordinal.{u1}) => And (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a (Ordinal.nadd.{u1} b c')))))
 Case conversion may be inaccurate. Consider using '#align ordinal.lt_nadd_iff Ordinal.lt_nadd_iffₓ'. -/
@@ -338,43 +362,63 @@ theorem lt_nadd_iff : a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' <
   simp [lt_blsub_iff]
 #align ordinal.lt_nadd_iff Ordinal.lt_nadd_iff
 
-#print Ordinal.nadd_le_iff /-
+/- warning: ordinal.nadd_le_iff -> Ordinal.nadd_le_iff is a dubious translation:
+lean 3 declaration is
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c) a) (And (forall (b' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b' c) a)) (forall (c' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c') a)))
+but is expected to have type
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c) a) (And (forall (b' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b' c) a)) (forall (c' : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c' c) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b c') a)))
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_iff Ordinal.nadd_le_iffₓ'. -/
 theorem nadd_le_iff : b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a :=
   by
   rw [nadd_def]
   simp [blsub_le_iff]
 #align ordinal.nadd_le_iff Ordinal.nadd_le_iff
--/
 
-#print Ordinal.nadd_lt_nadd_left /-
+/- warning: ordinal.nadd_lt_nadd_left -> Ordinal.nadd_lt_nadd_left is a dubious translation:
+lean 3 declaration is
+  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c))
+but is expected to have type
+  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c))
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_lt_nadd_left Ordinal.nadd_lt_nadd_leftₓ'. -/
 theorem nadd_lt_nadd_left (h : b < c) (a) : a ♯ b < a ♯ c :=
   lt_nadd_iff.2 (Or.inr ⟨b, h, le_rfl⟩)
 #align ordinal.nadd_lt_nadd_left Ordinal.nadd_lt_nadd_left
--/
 
-#print Ordinal.nadd_lt_nadd_right /-
+/- warning: ordinal.nadd_lt_nadd_right -> Ordinal.nadd_lt_nadd_right is a dubious translation:
+lean 3 declaration is
+  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a))
+but is expected to have type
+  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a))
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_lt_nadd_right Ordinal.nadd_lt_nadd_rightₓ'. -/
 theorem nadd_lt_nadd_right (h : b < c) (a) : b ♯ a < c ♯ a :=
   lt_nadd_iff.2 (Or.inl ⟨b, h, le_rfl⟩)
 #align ordinal.nadd_lt_nadd_right Ordinal.nadd_lt_nadd_right
--/
 
-#print Ordinal.nadd_le_nadd_left /-
+/- warning: ordinal.nadd_le_nadd_left -> Ordinal.nadd_le_nadd_left is a dubious translation:
+lean 3 declaration is
+  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c))
+but is expected to have type
+  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c))
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_nadd_left Ordinal.nadd_le_nadd_leftₓ'. -/
 theorem nadd_le_nadd_left (h : b ≤ c) (a) : a ♯ b ≤ a ♯ c :=
   by
   rcases lt_or_eq_of_le h with (h | rfl)
   · exact (nadd_lt_nadd_left h a).le
   · exact le_rfl
 #align ordinal.nadd_le_nadd_left Ordinal.nadd_le_nadd_left
--/
 
-#print Ordinal.nadd_le_nadd_right /-
+/- warning: ordinal.nadd_le_nadd_right -> Ordinal.nadd_le_nadd_right is a dubious translation:
+lean 3 declaration is
+  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a))
+but is expected to have type
+  forall {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c) -> (forall (a : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a))
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_nadd_right Ordinal.nadd_le_nadd_rightₓ'. -/
 theorem nadd_le_nadd_right (h : b ≤ c) (a) : b ♯ a ≤ c ♯ a :=
   by
   rcases lt_or_eq_of_le h with (h | rfl)
   · exact (nadd_lt_nadd_right h a).le
   · exact le_rfl
 #align ordinal.nadd_le_nadd_right Ordinal.nadd_le_nadd_right
--/
 
 variable (a b)
 
@@ -389,7 +433,7 @@ theorem nadd_comm : ∀ a b, a ♯ b = b ♯ a
 
 /- warning: ordinal.blsub_nadd_of_mono -> Ordinal.blsub_nadd_of_mono is a dubious translation:
 lean 3 declaration is
-  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}) {f : forall (c : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c (Ordinal.nadd.{u1} a b)) -> Ordinal.{max u1 u2}}, (forall {i : Ordinal.{u1}} {j : Ordinal.{u1}} (hi : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i (Ordinal.nadd.{u1} a b)) (hj : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) j (Ordinal.nadd.{u1} a b)), (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i j) -> (LE.le.{succ (max u1 u2)} Ordinal.{max u1 u2} (Preorder.toLE.{succ (max u1 u2)} Ordinal.{max u1 u2} (PartialOrder.toPreorder.{succ (max u1 u2)} Ordinal.{max u1 u2} Ordinal.partialOrder.{max u1 u2})) (f i hi) (f j hj))) -> (Eq.{succ (succ (max u1 u2))} Ordinal.{max u1 u2} (Ordinal.blsub.{u1, u2} (Ordinal.nadd.{u1} a b) f) (LinearOrder.max.{succ (max u1 u2)} Ordinal.{max u1 u2} Ordinal.linearOrder.{max u1 u2} (Ordinal.blsub.{u1, u2} a (fun (a' : Ordinal.{u1}) (ha' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => f (Ordinal.nadd.{u1} a' b) (Ordinal.nadd_lt_nadd_right.{u1} a' a ha' b))) (Ordinal.blsub.{u1, u2} b (fun (b' : Ordinal.{u1}) (hb' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => f (Ordinal.nadd.{u1} a b') (Ordinal.nadd_lt_nadd_left.{u1} b' b hb' a)))))
+  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}) {f : forall (c : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c (Ordinal.nadd.{u1} a b)) -> Ordinal.{max u1 u2}}, (forall {i : Ordinal.{u1}} {j : Ordinal.{u1}} (hi : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i (Ordinal.nadd.{u1} a b)) (hj : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) j (Ordinal.nadd.{u1} a b)), (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i j) -> (LE.le.{succ (max u1 u2)} Ordinal.{max u1 u2} (Preorder.toHasLe.{succ (max u1 u2)} Ordinal.{max u1 u2} (PartialOrder.toPreorder.{succ (max u1 u2)} Ordinal.{max u1 u2} Ordinal.partialOrder.{max u1 u2})) (f i hi) (f j hj))) -> (Eq.{succ (succ (max u1 u2))} Ordinal.{max u1 u2} (Ordinal.blsub.{u1, u2} (Ordinal.nadd.{u1} a b) f) (LinearOrder.max.{succ (max u1 u2)} Ordinal.{max u1 u2} Ordinal.linearOrder.{max u1 u2} (Ordinal.blsub.{u1, u2} a (fun (a' : Ordinal.{u1}) (ha' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => f (Ordinal.nadd.{u1} a' b) (Ordinal.nadd_lt_nadd_right.{u1} a' a ha' b))) (Ordinal.blsub.{u1, u2} b (fun (b' : Ordinal.{u1}) (hb' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => f (Ordinal.nadd.{u1} a b') (Ordinal.nadd_lt_nadd_left.{u1} b' b hb' a)))))
 but is expected to have type
   forall (a : Ordinal.{u1}) (b : Ordinal.{u1}) {f : forall (c : Ordinal.{u1}), (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) c (Ordinal.nadd.{u1} a b)) -> Ordinal.{max u1 u2}}, (forall {i : Ordinal.{u1}} {j : Ordinal.{u1}} (hi : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i (Ordinal.nadd.{u1} a b)) (hj : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) j (Ordinal.nadd.{u1} a b)), (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) i j) -> (LE.le.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} (Preorder.toLE.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} (PartialOrder.toPreorder.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} Ordinal.partialOrder.{max u1 u2})) (f i hi) (f j hj))) -> (Eq.{max (succ (succ u1)) (succ (succ u2))} Ordinal.{max u1 u2} (Ordinal.blsub.{u1, u2} (Ordinal.nadd.{u1} a b) f) (Max.max.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} (LinearOrder.toMax.{max (succ u1) (succ u2)} Ordinal.{max u1 u2} Ordinal.linearOrder.{max u1 u2}) (Ordinal.blsub.{u1, u2} a (fun (a' : Ordinal.{u1}) (ha' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) a' a) => f (Ordinal.nadd.{u1} a' b) (Ordinal.nadd_lt_nadd_right.{u1} a' a ha' b))) (Ordinal.blsub.{u1, u2} b (fun (b' : Ordinal.{u1}) (hb' : LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b' b) => f (Ordinal.nadd.{u1} a b') (Ordinal.nadd_lt_nadd_left.{u1} b' b hb' a)))))
 Case conversion may be inaccurate. Consider using '#align ordinal.blsub_nadd_of_mono Ordinal.blsub_nadd_of_monoₓ'. -/
@@ -490,7 +534,12 @@ theorem nat_nadd (n : ℕ) : ↑n ♯ a = a + n := by rw [nadd_comm, nadd_nat]
 #align ordinal.nat_nadd Ordinal.nat_nadd
 -/
 
-#print Ordinal.add_le_nadd /-
+/- warning: ordinal.add_le_nadd -> Ordinal.add_le_nadd is a dubious translation:
+lean 3 declaration is
+  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.hasAdd.{u1}) a b) (Ordinal.nadd.{u1} a b)
+but is expected to have type
+  forall (a : Ordinal.{u1}) (b : Ordinal.{u1}), LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.add.{u1}) a b) (Ordinal.nadd.{u1} a b)
+Case conversion may be inaccurate. Consider using '#align ordinal.add_le_nadd Ordinal.add_le_naddₓ'. -/
 theorem add_le_nadd : a + b ≤ a ♯ b := by
   apply b.limit_rec_on
   · simp
@@ -500,7 +549,6 @@ theorem add_le_nadd : a + b ≤ a ♯ b := by
     rw [← IsNormal.blsub_eq.{u, u} (add_is_normal a) hc, blsub_le_iff]
     exact fun i hi => (H i hi).trans_lt (nadd_lt_nadd_left hi a)
 #align ordinal.add_le_nadd Ordinal.add_le_nadd
--/
 
 end Ordinal
 
@@ -511,26 +559,38 @@ namespace NatOrdinal
 instance : Add NatOrdinal :=
   ⟨nadd⟩
 
-#print NatOrdinal.add_covariantClass_lt /-
+/- warning: nat_ordinal.add_covariant_class_lt -> NatOrdinal.add_covariantClass_lt is a dubious translation:
+lean 3 declaration is
+  CovariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.hasAdd.{u1})) (LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toHasLt.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
+but is expected to have type
+  CovariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3701 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3703 : NatOrdinal.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.instAddNatOrdinal.{u1}) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3701 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3703) (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3716 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3718 : NatOrdinal.{u1}) => LT.lt.{succ u1} NatOrdinal.{u1} (Preorder.toLT.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3716 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3718)
+Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_covariant_class_lt NatOrdinal.add_covariantClass_ltₓ'. -/
 instance add_covariantClass_lt : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· < ·) :=
   ⟨fun a b c h => nadd_lt_nadd_left h a⟩
 #align nat_ordinal.add_covariant_class_lt NatOrdinal.add_covariantClass_lt
--/
 
-#print NatOrdinal.add_covariantClass_le /-
+/- warning: nat_ordinal.add_covariant_class_le -> NatOrdinal.add_covariantClass_le is a dubious translation:
+lean 3 declaration is
+  CovariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.hasAdd.{u1})) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
+but is expected to have type
+  CovariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3749 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3751 : NatOrdinal.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.instAddNatOrdinal.{u1}) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3749 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3751) (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3764 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3766 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3764 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3766)
+Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_covariant_class_le NatOrdinal.add_covariantClass_leₓ'. -/
 instance add_covariantClass_le : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => nadd_le_nadd_left h a⟩
 #align nat_ordinal.add_covariant_class_le NatOrdinal.add_covariantClass_le
--/
 
-#print NatOrdinal.add_contravariantClass_le /-
+/- warning: nat_ordinal.add_contravariant_class_le -> NatOrdinal.add_contravariantClass_le is a dubious translation:
+lean 3 declaration is
+  ContravariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.hasAdd.{u1})) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))
+but is expected to have type
+  ContravariantClass.{succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3797 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3799 : NatOrdinal.{u1}) => HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.instAddNatOrdinal.{u1}) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3797 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3799) (fun (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3812 : NatOrdinal.{u1}) (x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3814 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3812 x._@.Mathlib.SetTheory.Ordinal.NaturalOps._hyg.3814)
+Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_leₓ'. -/
 instance add_contravariantClass_le :
     ContravariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => by
     by_contra' h'
     exact h.not_lt (add_lt_add_left h' a)⟩
 #align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_le
--/
 
 instance : OrderedCancelAddCommMonoid NatOrdinal :=
   { NatOrdinal.linearOrder with
@@ -559,7 +619,7 @@ theorem add_one_eq_succ : ∀ a : NatOrdinal, a + 1 = succ a :=
 
 /- warning: nat_ordinal.to_ordinal_cast_nat -> NatOrdinal.toOrdinal_cast_nat is a dubious translation:
 lean 3 declaration is
-  forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)
+  forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)
 but is expected to have type
   forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_cast_nat NatOrdinal.toOrdinal_cast_natₓ'. -/
@@ -583,7 +643,7 @@ namespace Ordinal
 
 /- warning: ordinal.to_nat_ordinal_cast_nat -> Ordinal.toNatOrdinal_cast_nat is a dubious translation:
 lean 3 declaration is
-  forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)
+  forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toHasLe.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)
 but is expected to have type
   forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_natₓ'. -/
@@ -594,53 +654,85 @@ theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n :=
   rfl
 #align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_nat
 
-#print Ordinal.lt_of_nadd_lt_nadd_left /-
+/- warning: ordinal.lt_of_nadd_lt_nadd_left -> Ordinal.lt_of_nadd_lt_nadd_left is a dubious translation:
+lean 3 declaration is
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+but is expected to have type
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+Case conversion may be inaccurate. Consider using '#align ordinal.lt_of_nadd_lt_nadd_left Ordinal.lt_of_nadd_lt_nadd_leftₓ'. -/
 theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c :=
   @lt_of_add_lt_add_left NatOrdinal _ _ _
 #align ordinal.lt_of_nadd_lt_nadd_left Ordinal.lt_of_nadd_lt_nadd_left
--/
 
-#print Ordinal.lt_of_nadd_lt_nadd_right /-
+/- warning: ordinal.lt_of_nadd_lt_nadd_right -> Ordinal.lt_of_nadd_lt_nadd_right is a dubious translation:
+lean 3 declaration is
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+but is expected to have type
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) -> (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+Case conversion may be inaccurate. Consider using '#align ordinal.lt_of_nadd_lt_nadd_right Ordinal.lt_of_nadd_lt_nadd_rightₓ'. -/
 theorem lt_of_nadd_lt_nadd_right : ∀ {a b c}, b ♯ a < c ♯ a → b < c :=
   @lt_of_add_lt_add_right NatOrdinal _ _ _
 #align ordinal.lt_of_nadd_lt_nadd_right Ordinal.lt_of_nadd_lt_nadd_right
--/
 
-#print Ordinal.le_of_nadd_le_nadd_left /-
+/- warning: ordinal.le_of_nadd_le_nadd_left -> Ordinal.le_of_nadd_le_nadd_left is a dubious translation:
+lean 3 declaration is
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) -> (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+but is expected to have type
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) -> (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+Case conversion may be inaccurate. Consider using '#align ordinal.le_of_nadd_le_nadd_left Ordinal.le_of_nadd_le_nadd_leftₓ'. -/
 theorem le_of_nadd_le_nadd_left : ∀ {a b c}, a ♯ b ≤ a ♯ c → b ≤ c :=
   @le_of_add_le_add_left NatOrdinal _ _ _
 #align ordinal.le_of_nadd_le_nadd_left Ordinal.le_of_nadd_le_nadd_left
--/
 
-#print Ordinal.le_of_nadd_le_nadd_right /-
+/- warning: ordinal.le_of_nadd_le_nadd_right -> Ordinal.le_of_nadd_le_nadd_right is a dubious translation:
+lean 3 declaration is
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) -> (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+but is expected to have type
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}} {c : Ordinal.{u1}}, (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) -> (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+Case conversion may be inaccurate. Consider using '#align ordinal.le_of_nadd_le_nadd_right Ordinal.le_of_nadd_le_nadd_rightₓ'. -/
 theorem le_of_nadd_le_nadd_right : ∀ {a b c}, b ♯ a ≤ c ♯ a → b ≤ c :=
   @le_of_add_le_add_right NatOrdinal _ _ _
 #align ordinal.le_of_nadd_le_nadd_right Ordinal.le_of_nadd_le_nadd_right
--/
 
-#print Ordinal.nadd_lt_nadd_iff_left /-
+/- warning: ordinal.nadd_lt_nadd_iff_left -> Ordinal.nadd_lt_nadd_iff_left is a dubious translation:
+lean 3 declaration is
+  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+but is expected to have type
+  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_lt_nadd_iff_left Ordinal.nadd_lt_nadd_iff_leftₓ'. -/
 theorem nadd_lt_nadd_iff_left : ∀ (a) {b c}, a ♯ b < a ♯ c ↔ b < c :=
   @add_lt_add_iff_left NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd_iff_left Ordinal.nadd_lt_nadd_iff_left
--/
 
-#print Ordinal.nadd_lt_nadd_iff_right /-
+/- warning: ordinal.nadd_lt_nadd_iff_right -> Ordinal.nadd_lt_nadd_iff_right is a dubious translation:
+lean 3 declaration is
+  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toHasLt.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+but is expected to have type
+  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) (LT.lt.{succ u1} Ordinal.{u1} (Preorder.toLT.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_lt_nadd_iff_right Ordinal.nadd_lt_nadd_iff_rightₓ'. -/
 theorem nadd_lt_nadd_iff_right : ∀ (a) {b c}, b ♯ a < c ♯ a ↔ b < c :=
   @add_lt_add_iff_right NatOrdinal _ _ _ _
 #align ordinal.nadd_lt_nadd_iff_right Ordinal.nadd_lt_nadd_iff_right
--/
 
-#print Ordinal.nadd_le_nadd_iff_left /-
+/- warning: ordinal.nadd_le_nadd_iff_left -> Ordinal.nadd_le_nadd_iff_left is a dubious translation:
+lean 3 declaration is
+  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+but is expected to have type
+  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} a b) (Ordinal.nadd.{u1} a c)) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_nadd_iff_left Ordinal.nadd_le_nadd_iff_leftₓ'. -/
 theorem nadd_le_nadd_iff_left : ∀ (a) {b c}, a ♯ b ≤ a ♯ c ↔ b ≤ c :=
   @add_le_add_iff_left NatOrdinal _ _ _ _
 #align ordinal.nadd_le_nadd_iff_left Ordinal.nadd_le_nadd_iff_left
--/
 
-#print Ordinal.nadd_le_nadd_iff_right /-
+/- warning: ordinal.nadd_le_nadd_iff_right -> Ordinal.nadd_le_nadd_iff_right is a dubious translation:
+lean 3 declaration is
+  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toHasLe.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+but is expected to have type
+  forall (a : Ordinal.{u1}) {b : Ordinal.{u1}} {c : Ordinal.{u1}}, Iff (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Ordinal.nadd.{u1} b a) (Ordinal.nadd.{u1} c a)) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) b c)
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_le_nadd_iff_right Ordinal.nadd_le_nadd_iff_rightₓ'. -/
 theorem nadd_le_nadd_iff_right : ∀ (a) {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c :=
   @add_le_add_iff_right NatOrdinal _ _ _ _
 #align ordinal.nadd_le_nadd_iff_right Ordinal.nadd_le_nadd_iff_right
--/
 
 #print Ordinal.nadd_left_cancel /-
 theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c :=

bump to nightly-2023-04-20-10

mathlib commit https://github.com/leanprover-community/mathlib/commit/730c6d4cab72b9d84fcfb9e95e8796e9cd8f40ba

fbfe5c3e

Diff

@@ -94,7 +94,7 @@ theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a)) a
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (a : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a)) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a)) a
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a)) a
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinalₓ'. -/
 @[simp]
 theorem toOrdinal_toNatOrdinal (a : NatOrdinal) : a.toOrdinal.toNatOrdinal = a :=
@@ -117,7 +117,7 @@ instance : IsWellOrder NatOrdinal (· < ·) :=
 lean 3 declaration is
   Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) Ordinal.zero.{u1}))
+  Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_zero NatOrdinal.toOrdinal_zeroₓ'. -/
 @[simp]
 theorem toOrdinal_zero : toOrdinal 0 = 0 :=
@@ -128,7 +128,7 @@ theorem toOrdinal_zero : toOrdinal 0 = 0 :=
 lean 3 declaration is
   Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) Ordinal.one.{u1}))
+  Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_one NatOrdinal.toOrdinal_oneₓ'. -/
 @[simp]
 theorem toOrdinal_one : toOrdinal 1 = 1 :=
@@ -139,7 +139,7 @@ theorem toOrdinal_one : toOrdinal 1 = 1 :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1}))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.zero.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1})))
+  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1})))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_zero NatOrdinal.toOrdinal_eq_zeroₓ'. -/
 @[simp]
 theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
@@ -150,7 +150,7 @@ theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1}))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.one.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1})))
+  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1})))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_one NatOrdinal.toOrdinal_eq_oneₓ'. -/
 @[simp]
 theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
@@ -161,7 +161,7 @@ theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
 lean 3 declaration is
   forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
 but is expected to have type
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (LinearOrder.toMax.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) b))
+  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_max NatOrdinal.toOrdinal_maxₓ'. -/
 @[simp]
 theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
@@ -172,7 +172,7 @@ theorem toOrdinal_max : (max a b).toOrdinal = max a.toOrdinal b.toOrdinal :=
 lean 3 declaration is
   forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} b))
 but is expected to have type
-  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (Min.min.{succ u1} NatOrdinal.{u1} (LinearOrder.toMin.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (Min.min.{succ u1} NatOrdinal.{u1} (LinearOrder.toMin.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (LinearOrder.toMin.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) b))
+  forall {a : NatOrdinal.{u1}} {b : NatOrdinal.{u1}}, Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Min.min.{succ u1} NatOrdinal.{u1} (LinearOrder.toMin.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_min NatOrdinal.toOrdinal_minₓ'. -/
 @[simp]
 theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
@@ -183,7 +183,7 @@ theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))) NatOrdinal.succOrder.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.hasAdd.{u1}) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) NatOrdinal.succOrder.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (HAdd.hAdd.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (instHAdd.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.add.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))))
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) NatOrdinal.succOrder.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.add.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.succ_def NatOrdinal.succ_defₓ'. -/
 theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
   rfl
@@ -193,7 +193,7 @@ theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
 lean 3 declaration is
   forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
 but is expected to have type
-  forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a)) -> (forall (a : NatOrdinal.{u1}), β a)
+  forall {β : NatOrdinal.{u1} -> Sort.{u2}}, (forall (a : Ordinal.{u1}), β (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a)) -> (forall (a : NatOrdinal.{u1}), β a)
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.rec NatOrdinal.recₓ'. -/
 /-- A recursor for `nat_ordinal`. Use as `induction x using nat_ordinal.rec`. -/
 protected def rec {β : NatOrdinal → Sort _} (h : ∀ a, β (toNatOrdinal a)) : ∀ a, β a := fun a =>
@@ -224,7 +224,7 @@ theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal :=
 lean 3 declaration is
   forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a)) a
 but is expected to have type
-  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (a : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a)) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a)) a
+  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a)) a
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_to_ordinal Ordinal.toNatOrdinal_toOrdinalₓ'. -/
 @[simp]
 theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
@@ -235,7 +235,7 @@ theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
 lean 3 declaration is
   Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) instNatOrdinalZero.{u1}))
+  Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_zero Ordinal.toNatOrdinal_zeroₓ'. -/
 @[simp]
 theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
@@ -246,7 +246,7 @@ theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
 lean 3 declaration is
   Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) instNatOrdinalOne.{u1}))
+  Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_one Ordinal.toNatOrdinal_oneₓ'. -/
 @[simp]
 theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
@@ -257,7 +257,7 @@ theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
 lean 3 declaration is
   forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))))
 but is expected to have type
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) instNatOrdinalZero.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1})))
+  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1})))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_zero Ordinal.toNatOrdinal_eq_zeroₓ'. -/
 @[simp]
 theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
@@ -268,7 +268,7 @@ theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
 lean 3 declaration is
   forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))))
 but is expected to have type
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) instNatOrdinalOne.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})))
+  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_oneₓ'. -/
 @[simp]
 theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
@@ -279,7 +279,7 @@ theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
 lean 3 declaration is
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.max.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.max.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
 but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) (LinearOrder.toMax.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) NatOrdinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) b))
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Max.max.{succ u1} Ordinal.{u1} (LinearOrder.toMax.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Max.max.{succ u1} NatOrdinal.{u1} (LinearOrder.toMax.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_maxₓ'. -/
 @[simp]
 theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOrdinal :=
@@ -290,7 +290,7 @@ theorem toNatOrdinal_max : toNatOrdinal (max a b) = max a.toNatOrdinal b.toNatOr
 lean 3 declaration is
   forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (LinearOrder.min.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1} a b)) (LinearOrder.min.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} b))
 but is expected to have type
-  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) b))
+  forall {a : Ordinal.{u1}} {b : Ordinal.{u1}}, Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) a b)) (Min.min.{succ u1} Ordinal.{u1} (LinearOrder.toMin.{succ u1} Ordinal.{u1} Ordinal.linearOrder.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} b))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_min Ordinal.toNatOrdinal_minₓ'. -/
 @[simp]
 theorem toNatOrdinal_min :
@@ -561,7 +561,7 @@ theorem add_one_eq_succ : ∀ a : NatOrdinal, a + 1 = succ a :=
 lean 3 declaration is
   forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)
 but is expected to have type
-  forall (n : Nat), Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) (AddMonoidWithOne.toNatCast.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) Ordinal.addMonoidWithOne.{u1}) n)
+  forall (n : Nat), Eq.{succ (succ u1)} Ordinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => Ordinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) NatOrdinal.toOrdinal.{u1} (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_cast_nat NatOrdinal.toOrdinal_cast_natₓ'. -/
 @[simp]
 theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n :=
@@ -585,7 +585,7 @@ namespace Ordinal
 lean 3 declaration is
   forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat Ordinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat Ordinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat Ordinal.{u1} (Nat.castCoe.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1})))) n)) ((fun (a : Type) (b : Type.{succ u1}) [self : HasLiftT.{1, succ (succ u1)} a b] => self.0) Nat NatOrdinal.{u1} (HasLiftT.mk.{1, succ (succ u1)} Nat NatOrdinal.{u1} (CoeTCₓ.coe.{1, succ (succ u1)} Nat NatOrdinal.{u1} (Nat.castCoe.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1})))) n)
 but is expected to have type
-  forall (n : Nat), Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (AddMonoidWithOne.toNatCast.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) NatOrdinal.addMonoidWithOne.{u1}) n)
+  forall (n : Nat), Eq.{succ (succ u1)} NatOrdinal.{u1} (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => NatOrdinal.{u1}) (RelHomClass.toFunLike.{succ u1, succ u1, succ u1} (RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) Ordinal.toNatOrdinal.{u1} (Nat.cast.{succ u1} Ordinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} Ordinal.{u1} Ordinal.addMonoidWithOne.{u1}) n)) (Nat.cast.{succ u1} NatOrdinal.{u1} (AddMonoidWithOne.toNatCast.{succ u1} NatOrdinal.{u1} NatOrdinal.addMonoidWithOne.{u1}) n)
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_cast_nat Ordinal.toNatOrdinal_cast_natₓ'. -/
 @[simp]
 theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n :=

bump to nightly-2023-02-23-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/3ade05ac9447ae31a22d2ea5423435e054131240

5c91f1b0

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
 
 ! This file was ported from Lean 3 source module set_theory.ordinal.natural_ops
-! leanprover-community/mathlib commit 2e0975f6a25dd3fbfb9e41556a77f075f6269748
+! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.SetTheory.Ordinal.Arithmetic
 /-!
 # Natural operations on ordinals
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The goal of this file is to define natural addition and multiplication on ordinals, also known as
 the Hessenberg sum and product, and provide a basic API. The natural addition of two ordinals
 `a ♯ b` is recursively defined as the least ordinal greater than `a' ♯ b` and `a ♯ b'` for `a' < a`

2e0975f6

bump to nightly-2023-02-22-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

294ba122

Diff

@@ -114,7 +114,7 @@ instance : IsWellOrder NatOrdinal (· < ·) :=
 lean 3 declaration is
   Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) Ordinal.hasZero.{u1}))
+  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1}))) Ordinal.zero.{u1}))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_zero NatOrdinal.toOrdinal_zeroₓ'. -/
 @[simp]
 theorem toOrdinal_zero : toOrdinal 0 = 0 :=
@@ -125,7 +125,7 @@ theorem toOrdinal_zero : toOrdinal 0 = 0 :=
 lean 3 declaration is
   Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) Ordinal.hasOne.{u1}))
+  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) Ordinal.one.{u1}))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_one NatOrdinal.toOrdinal_oneₓ'. -/
 @[simp]
 theorem toOrdinal_one : toOrdinal 1 = 1 :=
@@ -136,7 +136,7 @@ theorem toOrdinal_one : toOrdinal 1 = 1 :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1}))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.hasZero.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1})))
+  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.zero.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (Zero.toOfNat0.{succ u1} NatOrdinal.{u1} instNatOrdinalZero.{u1})))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_zero NatOrdinal.toOrdinal_eq_zeroₓ'. -/
 @[simp]
 theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
@@ -147,7 +147,7 @@ theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} Ordinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1}))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.hasOne.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1})))
+  forall (a : NatOrdinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.one.{u1}))) (Eq.{succ (succ u1)} NatOrdinal.{u1} a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1})))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.to_ordinal_eq_one NatOrdinal.toOrdinal_eq_oneₓ'. -/
 @[simp]
 theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 :=
@@ -180,7 +180,7 @@ theorem toOrdinal_min : (min a b).toOrdinal = min a.toOrdinal b.toOrdinal :=
 lean 3 declaration is
   forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))) NatOrdinal.succOrder.{u1} a) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} Ordinal.{u1} Ordinal.{u1} Ordinal.{u1} (instHAdd.{succ u1} Ordinal.{u1} Ordinal.hasAdd.{u1}) (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (fun (_x : RelIso.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) => NatOrdinal.{u1} -> Ordinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})))) NatOrdinal.toOrdinal.{u1} a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))))
 but is expected to have type
-  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) NatOrdinal.succOrder.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (HAdd.hAdd.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (instHAdd.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.hasAdd.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))))
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))) NatOrdinal.succOrder.{u1} a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (HAdd.hAdd.{succ u1, succ u1, succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.{u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) (instHAdd.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) a) Ordinal.add.{u1}) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} (fun (_x : NatOrdinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : NatOrdinal.{u1}) => Ordinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1}) NatOrdinal.{u1} Ordinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} NatOrdinal.{u1} Ordinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} NatOrdinal.{u1} Ordinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) NatOrdinal.toOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))))
 Case conversion may be inaccurate. Consider using '#align nat_ordinal.succ_def NatOrdinal.succ_defₓ'. -/
 theorem succ_def (a : NatOrdinal) : succ a = (a.toOrdinal + 1).toNatOrdinal :=
   rfl
@@ -232,7 +232,7 @@ theorem toNatOrdinal_toOrdinal (a : Ordinal) : a.toNatOrdinal.toOrdinal = a :=
 lean 3 declaration is
   Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))) instNatOrdinalZero.{u1}))
+  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1}))) instNatOrdinalZero.{u1}))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_zero Ordinal.toNatOrdinal_zeroₓ'. -/
 @[simp]
 theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
@@ -243,7 +243,7 @@ theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 :=
 lean 3 declaration is
   Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))
 but is expected to have type
-  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))) instNatOrdinalOne.{u1}))
+  Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) instNatOrdinalOne.{u1}))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_one Ordinal.toNatOrdinal_oneₓ'. -/
 @[simp]
 theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
@@ -254,7 +254,7 @@ theorem toNatOrdinal_one : toNatOrdinal 1 = 1 :=
 lean 3 declaration is
   forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 0 (OfNat.mk.{succ u1} NatOrdinal.{u1} 0 (Zero.zero.{succ u1} NatOrdinal.{u1} NatOrdinal.hasZero.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (OfNat.mk.{succ u1} Ordinal.{u1} 0 (Zero.zero.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1}))))
 but is expected to have type
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) instNatOrdinalZero.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.hasZero.{u1})))
+  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) 0 (Zero.toOfNat0.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) instNatOrdinalZero.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 0 (Zero.toOfNat0.{succ u1} Ordinal.{u1} Ordinal.zero.{u1})))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_zero Ordinal.toNatOrdinal_eq_zeroₓ'. -/
 @[simp]
 theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
@@ -265,7 +265,7 @@ theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 :=
 lean 3 declaration is
   forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} NatOrdinal.{u1} (coeFn.{succ (succ u1), succ (succ u1)} (OrderIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) (fun (_x : RelIso.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) => Ordinal.{u1} -> NatOrdinal.{u1}) (RelIso.hasCoeToFun.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}))) (LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (LinearOrder.toLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1}))))))) Ordinal.toNatOrdinal.{u1} a) (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))))
 but is expected to have type
-  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) instNatOrdinalOne.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))
+  forall (a : Ordinal.{u1}), Iff (Eq.{succ (succ u1)} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) (FunLike.coe.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} (fun (_x : Ordinal.{u1}) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) _x) (EmbeddingLike.toFunLike.{succ (succ u1), succ (succ u1), succ (succ u1)} (Function.Embedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1}) Ordinal.{u1} NatOrdinal.{u1} (Function.instEmbeddingLikeEmbedding.{succ (succ u1), succ (succ u1)} Ordinal.{u1} NatOrdinal.{u1})) (RelEmbedding.toEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{succ u1, succ u1} Ordinal.{u1} NatOrdinal.{u1} (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Ordinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Ordinal.{u1}) => LE.le.{succ u1} Ordinal.{u1} (Preorder.toLE.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1})) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : NatOrdinal.{u1}) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : NatOrdinal.{u1}) => LE.le.{succ u1} NatOrdinal.{u1} (Preorder.toLE.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (SemilatticeInf.toPartialOrder.{succ u1} NatOrdinal.{u1} (Lattice.toSemilatticeInf.{succ u1} NatOrdinal.{u1} (DistribLattice.toLattice.{succ u1} NatOrdinal.{u1} (instDistribLattice.{succ u1} NatOrdinal.{u1} NatOrdinal.linearOrder.{u1})))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) Ordinal.toNatOrdinal.{u1})) a) (OfNat.ofNat.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) 1 (One.toOfNat1.{succ u1} ((fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Ordinal.{u1}) => NatOrdinal.{u1}) a) instNatOrdinalOne.{u1}))) (Eq.{succ (succ u1)} Ordinal.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})))
 Case conversion may be inaccurate. Consider using '#align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_oneₓ'. -/
 @[simp]
 theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
@@ -436,7 +436,12 @@ theorem zero_nadd : 0 ♯ a = a := by rw [nadd_comm, nadd_zero]
 #align ordinal.zero_nadd Ordinal.zero_nadd
 -/
 
-#print Ordinal.nadd_one /-
+/- warning: ordinal.nadd_one -> Ordinal.nadd_one is a dubious translation:
+lean 3 declaration is
+  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1})))) (Order.succ.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}) Ordinal.succOrder.{u1} a)
+but is expected to have type
+  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} a (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1}))) (Order.succ.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}) Ordinal.succOrder.{u1} a)
+Case conversion may be inaccurate. Consider using '#align ordinal.nadd_one Ordinal.nadd_oneₓ'. -/
 @[simp]
 theorem nadd_one : a ♯ 1 = succ a :=
   by
@@ -445,13 +450,16 @@ theorem nadd_one : a ♯ 1 = succ a :=
   intro i hi
   rwa [IH i hi, succ_lt_succ_iff]
 #align ordinal.nadd_one Ordinal.nadd_one
--/
 
-#print Ordinal.one_nadd /-
+/- warning: ordinal.one_nadd -> Ordinal.one_nadd is a dubious translation:
+lean 3 declaration is
+  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (OfNat.mk.{succ u1} Ordinal.{u1} 1 (One.one.{succ u1} Ordinal.{u1} Ordinal.hasOne.{u1}))) a) (Order.succ.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}) Ordinal.succOrder.{u1} a)
+but is expected to have type
+  forall (a : Ordinal.{u1}), Eq.{succ (succ u1)} Ordinal.{u1} (Ordinal.nadd.{u1} (OfNat.ofNat.{succ u1} Ordinal.{u1} 1 (One.toOfNat1.{succ u1} Ordinal.{u1} Ordinal.one.{u1})) a) (Order.succ.{succ u1} Ordinal.{u1} (PartialOrder.toPreorder.{succ u1} Ordinal.{u1} Ordinal.partialOrder.{u1}) Ordinal.succOrder.{u1} a)
+Case conversion may be inaccurate. Consider using '#align ordinal.one_nadd Ordinal.one_naddₓ'. -/
 @[simp]
 theorem one_nadd : 1 ♯ a = succ a := by rw [nadd_comm, nadd_one]
 #align ordinal.one_nadd Ordinal.one_nadd
--/
 
 #print Ordinal.nadd_succ /-
 theorem nadd_succ : a ♯ succ b = succ (a ♯ b) := by rw [← nadd_one (a ♯ b), nadd_assoc, nadd_one]
@@ -535,12 +543,16 @@ instance : OrderedCancelAddCommMonoid NatOrdinal :=
 instance : AddMonoidWithOne NatOrdinal :=
   AddMonoidWithOne.unary
 
-#print NatOrdinal.add_one_eq_succ /-
+/- warning: nat_ordinal.add_one_eq_succ -> NatOrdinal.add_one_eq_succ is a dubious translation:
+lean 3 declaration is
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.hasAdd.{u1}) a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (OfNat.mk.{succ u1} NatOrdinal.{u1} 1 (One.one.{succ u1} NatOrdinal.{u1} NatOrdinal.hasOne.{u1})))) (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (OrderedCancelAddCommMonoid.toPartialOrder.{succ u1} NatOrdinal.{u1} NatOrdinal.orderedCancelAddCommMonoid.{u1})) NatOrdinal.succOrder.{u1} a)
+but is expected to have type
+  forall (a : NatOrdinal.{u1}), Eq.{succ (succ u1)} NatOrdinal.{u1} (HAdd.hAdd.{succ u1, succ u1, succ u1} NatOrdinal.{u1} NatOrdinal.{u1} NatOrdinal.{u1} (instHAdd.{succ u1} NatOrdinal.{u1} NatOrdinal.instAddNatOrdinal.{u1}) a (OfNat.ofNat.{succ u1} NatOrdinal.{u1} 1 (One.toOfNat1.{succ u1} NatOrdinal.{u1} instNatOrdinalOne.{u1}))) (Order.succ.{succ u1} NatOrdinal.{u1} (PartialOrder.toPreorder.{succ u1} NatOrdinal.{u1} (OrderedCancelAddCommMonoid.toPartialOrder.{succ u1} NatOrdinal.{u1} NatOrdinal.instOrderedCancelAddCommMonoidNatOrdinal.{u1})) NatOrdinal.succOrder.{u1} a)
+Case conversion may be inaccurate. Consider using '#align nat_ordinal.add_one_eq_succ NatOrdinal.add_one_eq_succₓ'. -/
 @[simp]
 theorem add_one_eq_succ : ∀ a : NatOrdinal, a + 1 = succ a :=
   nadd_one
 #align nat_ordinal.add_one_eq_succ NatOrdinal.add_one_eq_succ
--/
 
 /- warning: nat_ordinal.to_ordinal_cast_nat -> NatOrdinal.toOrdinal_cast_nat is a dubious translation:
 lean 3 declaration is

2e0975f6

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: avoid some unused variables (#11583)

These will be caught by the linter in a future lean version.

818ec230

Diff

@@ -292,7 +292,7 @@ theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
 
 theorem nadd_assoc (a b c) : a ♯ b ♯ c = a ♯ (b ♯ c) := by
   rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
-  · congr <;> ext (d hd) <;> apply nadd_assoc
+  · congr <;> ext <;> apply nadd_assoc
   · exact fun _ _ h => nadd_le_nadd_left h a
   · exact fun _ _ h => nadd_le_nadd_right h c
 termination_by (a, b, c)

chore: remove unneeded decreasing_by and termination_by (#11386)

The termination checker has been getting more capable, and many of the termination_by or decreasing_by clauses in Mathlib are no longer needed.

(Note that termination_by? will show the automatically derived termination expression, so no information is being lost by removing these.)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

c7950e4e

Diff

@@ -270,7 +270,6 @@ theorem nadd_comm : ∀ a b, a ♯ b = b ♯ a
   | a, b => by
     rw [nadd_def, nadd_def, max_comm]
     congr <;> ext <;> apply nadd_comm
-    -- Porting note: below was decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
   termination_by a b => (a,b)
 #align ordinal.nadd_comm Ordinal.nadd_comm
 
@@ -297,8 +296,6 @@ theorem nadd_assoc (a b c) : a ♯ b ♯ c = a ♯ (b ♯ c) := by
   · exact fun _ _ h => nadd_le_nadd_left h a
   · exact fun _ _ h => nadd_le_nadd_right h c
 termination_by (a, b, c)
--- Porting note: above lines replaces
--- decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd_assoc Ordinal.nadd_assoc
 
 @[simp]

refactor: do not allow nsmul and zsmul to default automatically (#6262)

This PR removes the default values for nsmul and zsmul, forcing the user to populate them manually. The previous behavior can be obtained by writing nsmul := nsmulRec and zsmul := zsmulRec, which is now in the docstring for these fields.

The motivation here is to make it more obvious when module diamonds are being introduced, or at least where they might be hiding; you can now simply search for nsmulRec in the source code.

Arguably we should do the same thing for intCast, natCast, pow, and zpow too, but diamonds are less common in those fields, so I'll leave them to a subsequent PR.

Co-authored-by: Matthew Ballard <matt@mrb.email>

e42f78a9

Diff

@@ -386,7 +386,8 @@ instance orderedCancelAddCommMonoid : OrderedCancelAddCommMonoid NatOrdinal :=
     zero := 0
     zero_add := zero_nadd
     add_zero := nadd_zero
-    add_comm := nadd_comm }
+    add_comm := nadd_comm
+    nsmul := nsmulRec }
 
 instance addMonoidWithOne : AddMonoidWithOne NatOrdinal :=
   AddMonoidWithOne.unary

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -54,7 +54,7 @@ noncomputable section
 
 /-- A type synonym for ordinals with natural addition and multiplication. -/
 def NatOrdinal : Type _ :=
-  -- porting note: used to derive LinearOrder & SuccOrder but need to manually define
+  -- Porting note: used to derive LinearOrder & SuccOrder but need to manually define
   Ordinal deriving Zero, Inhabited, One, WellFoundedRelation
 #align nat_ordinal NatOrdinal
 
@@ -83,7 +83,7 @@ theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
   rfl
 #align nat_ordinal.to_ordinal_symm_eq NatOrdinal.toOrdinal_symm_eq
 
--- porting note: used to use dot notation, but doesn't work in Lean 4 with `OrderIso`
+-- Porting note: used to use dot notation, but doesn't work in Lean 4 with `OrderIso`
 @[simp]
 theorem toOrdinal_toNatOrdinal (a : NatOrdinal) :
     Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a) = a := rfl
@@ -270,7 +270,7 @@ theorem nadd_comm : ∀ a b, a ♯ b = b ♯ a
   | a, b => by
     rw [nadd_def, nadd_def, max_comm]
     congr <;> ext <;> apply nadd_comm
-    -- porting note: below was decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+    -- Porting note: below was decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
   termination_by a b => (a,b)
 #align ordinal.nadd_comm Ordinal.nadd_comm

chore: move to v4.6.0-rc1, merging adaptations from bump/v4.6.0 (#10176)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Joachim Breitner <mail@joachim-breitner.de>

490d2d48

Diff

@@ -203,7 +203,7 @@ corresponding coefficients in the Cantor normal forms of `a` and `b`. -/
 noncomputable def nadd : Ordinal → Ordinal → Ordinal
   | a, b =>
     max (blsub.{u, u} a fun a' _ => nadd a' b) (blsub.{u, u} b fun b' _ => nadd a b')
-  termination_by nadd o₁ o₂ => (o₁, o₂)
+  termination_by o₁ o₂ => (o₁, o₂)
 #align ordinal.nadd Ordinal.nadd
 
 @[inherit_doc]
@@ -221,7 +221,7 @@ the Cantor normal forms of `a` and `b` as if they were polynomials in `ω`. Addi
 done via natural addition. -/
 noncomputable def nmul : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
   | a, b => sInf {c | ∀ a' < a, ∀ b' < b, nmul a' b ♯ nmul a b' < c ♯ nmul a' b'}
-termination_by nmul a b => (a, b)
+termination_by a b => (a, b)
 #align ordinal.nmul Ordinal.nmul
 
 @[inherit_doc]
@@ -271,7 +271,7 @@ theorem nadd_comm : ∀ a b, a ♯ b = b ♯ a
     rw [nadd_def, nadd_def, max_comm]
     congr <;> ext <;> apply nadd_comm
     -- porting note: below was decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
-  termination_by nadd_comm a b => (a,b)
+  termination_by a b => (a,b)
 #align ordinal.nadd_comm Ordinal.nadd_comm
 
 theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
@@ -296,7 +296,7 @@ theorem nadd_assoc (a b c) : a ♯ b ♯ c = a ♯ (b ♯ c) := by
   · congr <;> ext (d hd) <;> apply nadd_assoc
   · exact fun _ _ h => nadd_le_nadd_left h a
   · exact fun _ _ h => nadd_le_nadd_right h c
-termination_by _ => (a, b, c)
+termination_by (a, b, c)
 -- Porting note: above lines replaces
 -- decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd_assoc Ordinal.nadd_assoc
@@ -560,7 +560,7 @@ theorem nmul_comm : ∀ a b, a ⨳ b = b ⨳ a
       exact H _ hd _ hc
     · rw [nadd_comm, nmul_comm a d, nmul_comm c, nmul_comm c]
       exact H _ hd _ hc
-termination_by nmul_comm a b => (a, b)
+termination_by a b => (a, b)
 #align ordinal.nmul_comm Ordinal.nmul_comm
 
 @[simp]
@@ -587,7 +587,7 @@ theorem nmul_one (a : Ordinal) : a ⨳ 1 = a := by
   -- for the termination checker.
   · simpa only [nmul_one c] using H c hc
   · simpa only [nmul_one c] using hc.trans_le ha
-termination_by nmul_one a => a
+termination_by a
 #align ordinal.nmul_one Ordinal.nmul_one
 
 @[simp]
@@ -653,7 +653,7 @@ theorem nmul_nadd : ∀ a b c, a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
         nadd_left_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left, nadd_left_comm, nadd_comm (a' ⨳ c'),
         nadd_left_comm _ (a ⨳ c'), nadd_lt_nadd_iff_left, nadd_comm _ (a' ⨳ c'),
         nadd_comm _ (a' ⨳ c'), nadd_left_comm, nadd_lt_nadd_iff_left] at this
-termination_by nmul_nadd a b c => (a, b, c)
+termination_by a b c => (a, b, c)
 #align ordinal.nmul_nadd Ordinal.nmul_nadd
 
 theorem nadd_nmul (a b c) : (a ♯ b) ⨳ c = a ⨳ c ♯ b ⨳ c := by
@@ -757,7 +757,7 @@ theorem nmul_assoc : ∀ a b c, a ⨳ b ⨳ c = a ⨳ (b ⨳ c)
       rw [← nmul_assoc a' b c, ← nmul_assoc a b' c, ← nmul_assoc a b c', ← nmul_assoc a' b' c',
         ← nmul_assoc a' b' c, ← nmul_assoc a' b c', ← nmul_assoc a b' c']
       exact nmul_nadd_lt₃ ha hb hc
-termination_by nmul_assoc a b c => (a, b, c)
+termination_by a b c => (a, b, c)
 #align ordinal.nmul_assoc Ordinal.nmul_assoc
 
 end Ordinal

chore: Replace (· op ·) a by (a op ·) (#8843)

I used the regex $\(· (.) ·$ (.)\), replacing with ($2 $1 ·).

d14658b4

Diff

@@ -829,10 +829,7 @@ theorem mul_le_nmul (a b : Ordinal.{u}) : a * b ≤ a ⨳ b := by
   · intro c hc H
     rcases eq_zero_or_pos a with (rfl | ha)
     · simp
-    · -- Porting note: `this` was inline in the `rw`, but now needs a preliminary `dsimp at this`.
-      have := IsNormal.blsub_eq.{u, u} (mul_isNormal ha) hc
-      dsimp at this
-      rw [← this, blsub_le_iff]
+    · rw [← IsNormal.blsub_eq.{u, u} (mul_isNormal ha) hc, blsub_le_iff]
       exact fun i hi => (H i hi).trans_lt (nmul_lt_nmul_of_pos_left hi ha)
 #align nat_ordinal.mul_le_nmul NatOrdinal.mul_le_nmul

chore: rename by_contra' to by_contra! (#8797)

To fit with the "please try harder" convention of ! tactics.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

738b1a97

Diff

@@ -373,7 +373,7 @@ instance add_covariantClass_le : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (
 instance add_contravariantClass_le :
     ContravariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) :=
   ⟨fun a b c h => by
-    by_contra' h'
+    by_contra! h'
     exact h.not_lt (add_lt_add_left h' a)⟩
 #align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_le

style: add missing spaces around colons (#8293)

This is not exhaustive

c488ddff

Diff

@@ -58,9 +58,9 @@ def NatOrdinal : Type _ :=
   Ordinal deriving Zero, Inhabited, One, WellFoundedRelation
 #align nat_ordinal NatOrdinal
 
-instance NatOrdinal.linearOrder: LinearOrder NatOrdinal := {Ordinal.linearOrder with}
+instance NatOrdinal.linearOrder : LinearOrder NatOrdinal := {Ordinal.linearOrder with}
 
-instance NatOrdinal.succOrder: SuccOrder NatOrdinal := {Ordinal.succOrder with}
+instance NatOrdinal.succOrder : SuccOrder NatOrdinal := {Ordinal.succOrder with}
 
 /-- The identity function between `Ordinal` and `NatOrdinal`. -/
 @[match_pattern]

chore: only four spaces for subsequent lines (#7286)

Co-authored-by: Moritz Firsching <firsching@google.com>

0c7d6fa5

Diff

@@ -86,7 +86,7 @@ theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
 -- porting note: used to use dot notation, but doesn't work in Lean 4 with `OrderIso`
 @[simp]
 theorem toOrdinal_toNatOrdinal (a : NatOrdinal) :
-  Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a) = a := rfl
+    Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a) = a := rfl
 #align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinal
 
 theorem lt_wf : @WellFounded NatOrdinal (· < ·) :=

chore: tidy various files (#7132)

7eb27432

Diff

@@ -50,7 +50,7 @@ open Function Order
 
 noncomputable section
 
-/-! ### Basic casts between `ordinal` and `nat_ordinal` -/
+/-! ### Basic casts between `Ordinal` and `NatOrdinal` -/
 
 /-- A type synonym for ordinals with natural addition and multiplication. -/
 def NatOrdinal : Type _ :=

style: a linter for colons (#6761)

A linter that throws on seeing a colon at the start of a line, according to the style guideline that says these operators should go before linebreaks.

69a3de31

Diff

@@ -85,8 +85,8 @@ theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
 
 -- porting note: used to use dot notation, but doesn't work in Lean 4 with `OrderIso`
 @[simp]
-theorem toOrdinal_toNatOrdinal (a : NatOrdinal) : Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a) = a
- := rfl
+theorem toOrdinal_toNatOrdinal (a : NatOrdinal) :
+  Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a) = a := rfl
 #align nat_ordinal.to_ordinal_to_nat_ordinal NatOrdinal.toOrdinal_toNatOrdinal
 
 theorem lt_wf : @WellFounded NatOrdinal (· < ·) :=

fix: disable autoImplicit globally (#6528)

Autoimplicits are highly controversial and also defeat the performance-improving work in #6474.

The intent of this PR is to make autoImplicit opt-in on a per-file basis, by disabling it in the lakefile and enabling it again with set_option autoImplicit true in the few files that rely on it.

That also keeps this PR small, as opposed to attempting to "fix" files to not need it any more.

I claim that many of the uses of autoImplicit in these files are accidental; situations such as:

Assuming variables are in scope, but pasting the lemma in the wrong section
Pasting in a lemma from a scratch file without checking to see if the variable names are consistent with the rest of the file
Making a copy-paste error between lemmas and forgetting to add an explicit arguments.

Having set_option autoImplicit false as the default prevents these types of mistake being made in the 90% of files where autoImplicits are not used at all, and causes them to be caught by CI during review.

I think there were various points during the port where we encouraged porters to delete the universes u v lines; I think having autoparams for universe variables only would cover a lot of the cases we actually use them, while avoiding any real shortcomings.

A Zulip poll (after combining overlapping votes accordingly) was in favor of this change with 5:5:18 as the no:dontcare:yes vote ratio.

While this PR was being reviewed, a handful of files gained some more likely-accidental autoImplicits. In these places, set_option autoImplicit true has been placed locally within a section, rather than at the top of the file.

0c24f831

Diff

@@ -41,6 +41,8 @@ between both types, we attempt to prove and state most results on `Ordinal`.
   form.
 -/
 
+set_option autoImplicit true
+
 
 universe u v

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -132,7 +132,7 @@ theorem succ_def (a : NatOrdinal) : succ a = toNatOrdinal (toOrdinal a + 1) :=
 #align nat_ordinal.succ_def NatOrdinal.succ_def
 
 /-- A recursor for `NatOrdinal`. Use as `induction x using NatOrdinal.rec`. -/
-protected def rec {β : NatOrdinal → Sort _} (h : ∀ a, β (toNatOrdinal a)) : ∀ a, β a := fun a =>
+protected def rec {β : NatOrdinal → Sort*} (h : ∀ a, β (toNatOrdinal a)) : ∀ a, β a := fun a =>
   h (toOrdinal a)
 #align nat_ordinal.rec NatOrdinal.rec

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Violeta Hernández Palacios. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
-
-! This file was ported from Lean 3 source module set_theory.ordinal.natural_ops
-! leanprover-community/mathlib commit 31b269b60935483943542d547a6dd83a66b37dc7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.SetTheory.Ordinal.Arithmetic
 import Mathlib.Tactic.Abel
 
+#align_import set_theory.ordinal.natural_ops from "leanprover-community/mathlib"@"31b269b60935483943542d547a6dd83a66b37dc7"
+
 /-!
 # Natural operations on ordinals

chore: cleanup whitespace (#5988)

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

12343aa5

Diff

@@ -295,8 +295,8 @@ theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
 theorem nadd_assoc (a b c) : a ♯ b ♯ c = a ♯ (b ♯ c) := by
   rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
   · congr <;> ext (d hd) <;> apply nadd_assoc
-  · exact fun  _ _ h => nadd_le_nadd_left h a
-  · exact fun  _ _ h => nadd_le_nadd_right h c
+  · exact fun _ _ h => nadd_le_nadd_left h a
+  · exact fun _ _ h => nadd_le_nadd_right h c
 termination_by _ => (a, b, c)
 -- Porting note: above lines replaces
 -- decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]

chore: forward port #14324 (#5973)

This is the remainder of the forward port of https://github.com/leanprover-community/mathlib/pull/14324.

See https://leanprover-community.github.io/mathlib-port-status/file/set_theory/ordinal/natural_ops for the relevant #outofsync page.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

a3e15d84

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
 
 ! This file was ported from Lean 3 source module set_theory.ordinal.natural_ops
-! leanprover-community/mathlib commit 740acc0e6f9adf4423f92a485d0456fc271482da
+! leanprover-community/mathlib commit 31b269b60935483943542d547a6dd83a66b37dc7
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -79,8 +79,6 @@ namespace NatOrdinal
 
 open Ordinal
 
-variable {a b c : NatOrdinal.{u}}
-
 @[simp]
 theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal :=
   rfl
@@ -183,16 +181,20 @@ theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
 #align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_one
 
 @[simp]
-theorem toNatOrdinal_max : toNatOrdinal (max a b) = max (toNatOrdinal a) (toNatOrdinal b ) :=
+theorem toNatOrdinal_max (a b : Ordinal) :
+    toNatOrdinal (max a b) = max (toNatOrdinal a) (toNatOrdinal b) :=
   rfl
 #align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_max
 
 @[simp]
-theorem toNatOrdinal_min :
+theorem toNatOrdinal_min (a b : Ordinal) :
     toNatOrdinal (linearOrder.min a b) = linearOrder.min (toNatOrdinal a) (toNatOrdinal b) :=
   rfl
 #align ordinal.to_nat_ordinal_min Ordinal.toNatOrdinal_min
 
+/-! We place the definitions of `nadd` and `nmul` before actually developing their API, as this
+guarantees we only need to open the `NaturalOps` locale once. -/
+
 /-- Natural addition on ordinals `a ♯ b`, also known as the Hessenberg sum, is recursively defined
 as the least ordinal greater than `a' ♯ b` and `a ♯ b'` for all `a' < a` and `b' < b`. In contrast
 to normal ordinal addition, it is commutative.
@@ -210,6 +212,24 @@ scoped[NaturalOps] infixl:65 " ♯ " => Ordinal.nadd
 
 open NaturalOps
 
+/-- Natural multiplication on ordinals `a ⨳ b`, also known as the Hessenberg product, is recursively
+defined as the least ordinal such that `a ⨳ b + a' ⨳ b'` is greater than `a' ⨳ b + a ⨳ b'` for all
+`a' < a` and `b < b'`. In contrast to normal ordinal multiplication, it is commutative and
+distributive (over natural addition).
+
+Natural multiplication can equivalently be characterized as the ordinal resulting from multiplying
+the Cantor normal forms of `a` and `b` as if they were polynomials in `ω`. Addition of exponents is
+done via natural addition. -/
+noncomputable def nmul : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
+  | a, b => sInf {c | ∀ a' < a, ∀ b' < b, nmul a' b ♯ nmul a b' < c ♯ nmul a' b'}
+termination_by nmul a b => (a, b)
+#align ordinal.nmul Ordinal.nmul
+
+@[inherit_doc]
+scoped[NaturalOps] infixl:70 " ⨳ " => Ordinal.nmul
+
+/-! ### Natural addition -/
+
 theorem nadd_def (a b : Ordinal) :
     a ♯ b = max (blsub.{u, u} a fun a' _ => a' ♯ b) (blsub.{u, u} b fun b' _ => a ♯ b') := by
   rw [nadd]
@@ -336,10 +356,10 @@ theorem add_le_nadd : a + b ≤ a ♯ b := by
 
 end Ordinal
 
-open Ordinal
-
 namespace NatOrdinal
 
+open Ordinal NaturalOps
+
 instance : Add NatOrdinal :=
   ⟨nadd⟩
 
@@ -358,7 +378,7 @@ instance add_contravariantClass_le :
     exact h.not_lt (add_lt_add_left h' a)⟩
 #align nat_ordinal.add_contravariant_class_le NatOrdinal.add_contravariantClass_le
 
-instance : OrderedCancelAddCommMonoid NatOrdinal :=
+instance orderedCancelAddCommMonoid : OrderedCancelAddCommMonoid NatOrdinal :=
   { NatOrdinal.linearOrder with
     add := (· + ·)
     add_assoc := nadd_assoc
@@ -381,9 +401,8 @@ theorem add_one_eq_succ : ∀ a : NatOrdinal, a + 1 = succ a :=
 theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n := by
   induction' n with n hn
   · rfl
-  · change nadd (toOrdinal n) 1 = n + 1
-    rw [hn]
-    apply nadd_one
+  · change (toOrdinal n) ♯ 1 = n + 1
+    rw [hn]; exact nadd_one n
 #align nat_ordinal.to_ordinal_cast_nat NatOrdinal.toOrdinal_cast_nat
 
 end NatOrdinal
@@ -394,6 +413,10 @@ open NaturalOps
 
 namespace Ordinal
 
+theorem nadd_eq_add (a b : Ordinal) : a ♯ b = toOrdinal (toNatOrdinal a + toNatOrdinal b) :=
+  rfl
+#align ordinal.nadd_eq_add Ordinal.nadd_eq_add
+
 @[simp]
 theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n := by
   rw [← toOrdinal_cast_nat n]
@@ -432,6 +455,22 @@ theorem nadd_le_nadd_iff_right : ∀ (a) {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c
   @_root_.add_le_add_iff_right NatOrdinal _ _ _ _
 #align ordinal.nadd_le_nadd_iff_right Ordinal.nadd_le_nadd_iff_right
 
+theorem nadd_le_nadd : ∀ {a b c d}, a ≤ b → c ≤ d → a ♯ c ≤ b ♯ d :=
+  @add_le_add NatOrdinal _ _ _ _
+#align ordinal.nadd_le_nadd Ordinal.nadd_le_nadd
+
+theorem nadd_lt_nadd : ∀ {a b c d}, a < b → c < d → a ♯ c < b ♯ d :=
+  @add_lt_add NatOrdinal _ _ _ _
+#align ordinal.nadd_lt_nadd Ordinal.nadd_lt_nadd
+
+theorem nadd_lt_nadd_of_lt_of_le : ∀ {a b c d}, a < b → c ≤ d → a ♯ c < b ♯ d :=
+  @add_lt_add_of_lt_of_le NatOrdinal _ _ _ _
+#align ordinal.nadd_lt_nadd_of_lt_of_le Ordinal.nadd_lt_nadd_of_lt_of_le
+
+theorem nadd_lt_nadd_of_le_of_lt : ∀ {a b c d}, a ≤ b → c < d → a ♯ c < b ♯ d :=
+  @add_lt_add_of_le_of_lt NatOrdinal _ _ _ _
+#align ordinal.nadd_lt_nadd_of_le_of_lt Ordinal.nadd_lt_nadd_of_le_of_lt
+
 theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c :=
   @_root_.add_left_cancel NatOrdinal _ _
 #align ordinal.nadd_left_cancel Ordinal.nadd_left_cancel
@@ -448,4 +487,354 @@ theorem nadd_right_cancel_iff : ∀ {a b c}, b ♯ a = c ♯ a ↔ b = c :=
   @add_right_cancel_iff NatOrdinal _ _
 #align ordinal.nadd_right_cancel_iff Ordinal.nadd_right_cancel_iff
 
+theorem le_nadd_self {a b} : a ≤ b ♯ a := by simpa using nadd_le_nadd_right (Ordinal.zero_le b) a
+#align ordinal.le_nadd_self Ordinal.le_nadd_self
+
+theorem le_nadd_left {a b c} (h : a ≤ c) : a ≤ b ♯ c :=
+  le_nadd_self.trans (nadd_le_nadd_left h b)
+#align ordinal.le_nadd_left Ordinal.le_nadd_left
+
+theorem le_self_nadd {a b} : a ≤ a ♯ b := by simpa using nadd_le_nadd_left (Ordinal.zero_le b) a
+#align ordinal.le_self_nadd Ordinal.le_self_nadd
+
+theorem le_nadd_right {a b c} (h : a ≤ b) : a ≤ b ♯ c :=
+  le_self_nadd.trans (nadd_le_nadd_right h c)
+#align ordinal.le_nadd_right Ordinal.le_nadd_right
+
+theorem nadd_left_comm : ∀ a b c, a ♯ (b ♯ c) = b ♯ (a ♯ c) :=
+  @add_left_comm NatOrdinal _
+#align ordinal.nadd_left_comm Ordinal.nadd_left_comm
+
+theorem nadd_right_comm : ∀ a b c, a ♯ b ♯ c = a ♯ c ♯ b :=
+  @add_right_comm NatOrdinal _
+#align ordinal.nadd_right_comm Ordinal.nadd_right_comm
+
+/-! ### Natural multiplication -/
+
+variable {a b c d : Ordinal.{u}}
+
+theorem nmul_def (a b : Ordinal) :
+    a ⨳ b = sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'} := by rw [nmul]
+#align ordinal.nmul_def Ordinal.nmul_def
+
+/-- The set in the definition of `nmul` is nonempty. -/
+theorem nmul_nonempty (a b : Ordinal.{u}) :
+    {c : Ordinal.{u} | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}.Nonempty :=
+  ⟨_, fun _ ha _ hb => (lt_blsub₂.{u, u, u} _ ha hb).trans_le le_self_nadd⟩
+#align ordinal.nmul_nonempty Ordinal.nmul_nonempty
+
+theorem nmul_nadd_lt {a' b' : Ordinal} (ha : a' < a) (hb : b' < b) :
+    a' ⨳ b ♯ a ⨳ b' < a ⨳ b ♯ a' ⨳ b' := by
+  rw [nmul_def a b]
+  exact csInf_mem (nmul_nonempty a b) a' ha b' hb
+#align ordinal.nmul_nadd_lt Ordinal.nmul_nadd_lt
+
+theorem nmul_nadd_le {a' b' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
+    a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b' := by
+  rcases lt_or_eq_of_le ha with (ha | rfl)
+  · rcases lt_or_eq_of_le hb with (hb | rfl)
+    · exact (nmul_nadd_lt ha hb).le
+    · rw [nadd_comm]
+  · exact le_rfl
+#align ordinal.nmul_nadd_le Ordinal.nmul_nadd_le
+
+theorem lt_nmul_iff : c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b' := by
+  refine' ⟨fun h => _, _⟩
+  · rw [nmul] at h
+    simpa using not_mem_of_lt_csInf h ⟨0, fun _ _ => bot_le⟩
+  · rintro ⟨a', ha, b', hb, h⟩
+    have := h.trans_lt (nmul_nadd_lt ha hb)
+    rwa [nadd_lt_nadd_iff_right] at this
+#align ordinal.lt_nmul_iff Ordinal.lt_nmul_iff
+
+theorem nmul_le_iff : a ⨳ b ≤ c ↔ ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b' := by
+  rw [← not_iff_not]; simp [lt_nmul_iff]
+#align ordinal.nmul_le_iff Ordinal.nmul_le_iff
+
+theorem nmul_comm : ∀ a b, a ⨳ b = b ⨳ a
+  | a, b => by
+    rw [nmul, nmul]
+    congr; ext x; constructor <;> intro H c hc d hd
+    -- Porting note: had to add additional arguments to `nmul_comm` here
+    -- for the termination checker.
+    · rw [nadd_comm, ← nmul_comm d b, ← nmul_comm a c, ← nmul_comm d]
+      exact H _ hd _ hc
+    · rw [nadd_comm, nmul_comm a d, nmul_comm c, nmul_comm c]
+      exact H _ hd _ hc
+termination_by nmul_comm a b => (a, b)
+#align ordinal.nmul_comm Ordinal.nmul_comm
+
+@[simp]
+theorem nmul_zero (a) : a ⨳ 0 = 0 := by
+  rw [← Ordinal.le_zero, nmul_le_iff]
+  exact fun _ _ a ha => (Ordinal.not_lt_zero a ha).elim
+#align ordinal.nmul_zero Ordinal.nmul_zero
+
+@[simp]
+theorem zero_nmul (a) : 0 ⨳ a = 0 := by rw [nmul_comm, nmul_zero]
+#align ordinal.zero_nmul Ordinal.zero_nmul
+
+@[simp]
+theorem nmul_one (a : Ordinal) : a ⨳ 1 = a := by
+  rw [nmul]
+  simp only [lt_one_iff_zero, forall_eq, nmul_zero, nadd_zero]
+  convert csInf_Ici (α := Ordinal)
+  ext b
+  -- Porting note: added this `simp` line, as the result from `convert`
+  -- is slightly different.
+  simp only [Set.mem_setOf_eq, Set.mem_Ici]
+  refine' ⟨fun H => le_of_forall_lt fun c hc => _, fun ha c hc => _⟩
+  -- Porting note: had to add arguments to `nmul_one` in the next two lines
+  -- for the termination checker.
+  · simpa only [nmul_one c] using H c hc
+  · simpa only [nmul_one c] using hc.trans_le ha
+termination_by nmul_one a => a
+#align ordinal.nmul_one Ordinal.nmul_one
+
+@[simp]
+theorem one_nmul (a) : 1 ⨳ a = a := by rw [nmul_comm, nmul_one]
+#align ordinal.one_nmul Ordinal.one_nmul
+
+theorem nmul_lt_nmul_of_pos_left (h₁ : a < b) (h₂ : 0 < c) : c ⨳ a < c ⨳ b :=
+  lt_nmul_iff.2 ⟨0, h₂, a, h₁, by simp⟩
+#align ordinal.nmul_lt_nmul_of_pos_left Ordinal.nmul_lt_nmul_of_pos_left
+
+theorem nmul_lt_nmul_of_pos_right (h₁ : a < b) (h₂ : 0 < c) : a ⨳ c < b ⨳ c :=
+  lt_nmul_iff.2 ⟨a, h₁, 0, h₂, by simp⟩
+#align ordinal.nmul_lt_nmul_of_pos_right Ordinal.nmul_lt_nmul_of_pos_right
+
+theorem nmul_le_nmul_of_nonneg_left (h₁ : a ≤ b) (h₂ : 0 ≤ c) : c ⨳ a ≤ c ⨳ b := by
+  rcases lt_or_eq_of_le h₁ with (h₁ | rfl) <;> rcases lt_or_eq_of_le h₂ with (h₂ | rfl)
+  · exact (nmul_lt_nmul_of_pos_left h₁ h₂).le
+  all_goals simp
+#align ordinal.nmul_le_nmul_of_nonneg_left Ordinal.nmul_le_nmul_of_nonneg_left
+
+theorem nmul_le_nmul_of_nonneg_right (h₁ : a ≤ b) (h₂ : 0 ≤ c) : a ⨳ c ≤ b ⨳ c := by
+  rw [nmul_comm, nmul_comm b]
+  exact nmul_le_nmul_of_nonneg_left h₁ h₂
+#align ordinal.nmul_le_nmul_of_nonneg_right Ordinal.nmul_le_nmul_of_nonneg_right
+
+theorem nmul_nadd : ∀ a b c, a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
+  | a, b, c => by
+    refine le_antisymm (nmul_le_iff.2 fun a' ha d hd => ?_)
+      (nadd_le_iff.2 ⟨fun d hd => ?_, fun d hd => ?_⟩)
+    · -- Porting note: adding arguments to `nmul_nadd` for the termination checker.
+      rw [nmul_nadd a' b c]
+      rcases lt_nadd_iff.1 hd with (⟨b', hb, hd⟩ | ⟨c', hc, hd⟩)
+      · have := nadd_lt_nadd_of_lt_of_le (nmul_nadd_lt ha hb) (nmul_nadd_le ha.le hd)
+        -- Porting note: adding arguments to `nmul_nadd` for the termination checker.
+        rw [nmul_nadd a' b' c, nmul_nadd a b' c] at this
+        simp only [nadd_assoc] at this
+        rwa [nadd_left_comm, nadd_left_comm _ (a ⨳ b'), nadd_left_comm (a ⨳ b),
+          nadd_lt_nadd_iff_left, nadd_left_comm (a' ⨳ b), nadd_left_comm (a ⨳ b),
+          nadd_lt_nadd_iff_left, ← nadd_assoc, ← nadd_assoc] at this
+      · have := nadd_lt_nadd_of_le_of_lt (nmul_nadd_le ha.le hd) (nmul_nadd_lt ha hc)
+        -- Porting note: adding arguments to `nmul_nadd` for the termination checker.
+        rw [nmul_nadd a' b c', nmul_nadd a b c'] at this
+        simp only [nadd_assoc] at this
+        rwa [nadd_left_comm, nadd_comm (a ⨳ c), nadd_left_comm (a' ⨳ d), nadd_left_comm (a ⨳ c'),
+          nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, nadd_comm (a' ⨳ c), nadd_left_comm (a ⨳ d),
+          nadd_left_comm (a' ⨳ b), nadd_left_comm (a ⨳ b), nadd_lt_nadd_iff_left, nadd_comm (a ⨳ d),
+          nadd_comm (a' ⨳ d), ← nadd_assoc, ← nadd_assoc] at this
+    · rcases lt_nmul_iff.1 hd with ⟨a', ha, b', hb, hd⟩
+      have := nadd_lt_nadd_of_le_of_lt hd (nmul_nadd_lt ha (nadd_lt_nadd_right hb c))
+      -- Porting note: adding arguments to `nmul_nadd` for the termination checker.
+      rw [nmul_nadd a' b c, nmul_nadd a b' c, nmul_nadd a'] at this
+      simp only [nadd_assoc] at this
+      rwa [nadd_left_comm (a' ⨳ b'), nadd_left_comm, nadd_lt_nadd_iff_left, nadd_left_comm,
+        nadd_left_comm _ (a' ⨳ b'), nadd_left_comm (a ⨳ b'), nadd_lt_nadd_iff_left,
+        nadd_left_comm (a' ⨳ c), nadd_left_comm, nadd_lt_nadd_iff_left, nadd_left_comm,
+        nadd_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left] at this
+    · rcases lt_nmul_iff.1 hd with ⟨a', ha, c', hc, hd⟩
+      have := nadd_lt_nadd_of_lt_of_le (nmul_nadd_lt ha (nadd_lt_nadd_left hc b)) hd
+      -- Porting note: adding arguments to `nmul_nadd` for the termination checker.
+      rw [nmul_nadd a' b c, nmul_nadd a b c', nmul_nadd a'] at this
+      simp only [nadd_assoc] at this
+      rwa [nadd_left_comm _ (a' ⨳ b), nadd_lt_nadd_iff_left, nadd_left_comm (a' ⨳ c'),
+        nadd_left_comm _ (a' ⨳ c), nadd_lt_nadd_iff_left, nadd_left_comm, nadd_comm (a' ⨳ c'),
+        nadd_left_comm _ (a ⨳ c'), nadd_lt_nadd_iff_left, nadd_comm _ (a' ⨳ c'),
+        nadd_comm _ (a' ⨳ c'), nadd_left_comm, nadd_lt_nadd_iff_left] at this
+termination_by nmul_nadd a b c => (a, b, c)
+#align ordinal.nmul_nadd Ordinal.nmul_nadd
+
+theorem nadd_nmul (a b c) : (a ♯ b) ⨳ c = a ⨳ c ♯ b ⨳ c := by
+  rw [nmul_comm, nmul_nadd, nmul_comm, nmul_comm c]
+#align ordinal.nadd_nmul Ordinal.nadd_nmul
+
+theorem nmul_nadd_lt₃ {a' b' c' : Ordinal} (ha : a' < a) (hb : b' < b) (hc : c' < c) :
+    a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' <
+      a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' := by
+  simpa only [nadd_nmul, ← nadd_assoc] using nmul_nadd_lt (nmul_nadd_lt ha hb) hc
+#align ordinal.nmul_nadd_lt₃ Ordinal.nmul_nadd_lt₃
+
+theorem nmul_nadd_le₃ {a' b' c' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (hc : c' ≤ c) :
+    a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' ≤
+      a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' := by
+  simpa only [nadd_nmul, ← nadd_assoc] using nmul_nadd_le (nmul_nadd_le ha hb) hc
+#align ordinal.nmul_nadd_le₃ Ordinal.nmul_nadd_le₃
+
+theorem nmul_nadd_lt₃' {a' b' c' : Ordinal} (ha : a' < a) (hb : b' < b) (hc : c' < c) :
+    a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
+      a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') := by
+  simp only [nmul_comm _ (_ ⨳ _)]
+  convert nmul_nadd_lt₃ hb hc ha using 1 <;>
+    · simp only [nadd_eq_add, NatOrdinal.toOrdinal_toNatOrdinal]; abel_nf
+#align ordinal.nmul_nadd_lt₃' Ordinal.nmul_nadd_lt₃'
+
+theorem nmul_nadd_le₃' {a' b' c' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) (hc : c' ≤ c) :
+    a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') ≤
+      a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') := by
+  simp only [nmul_comm _ (_ ⨳ _)]
+  convert nmul_nadd_le₃ hb hc ha using 1 <;>
+    · simp only [nadd_eq_add, NatOrdinal.toOrdinal_toNatOrdinal]; abel_nf
+#align ordinal.nmul_nadd_le₃' Ordinal.nmul_nadd_le₃'
+
+theorem lt_nmul_iff₃ :
+    d < a ⨳ b ⨳ c ↔
+      ∃ a' < a, ∃ b' < b, ∃ c' < c,
+        d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' ≤
+          a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' := by
+  -- Porting note: was `refine' ⟨fun h => _, _⟩`, but can't get that to work?
+  constructor
+  · intro h
+    rcases lt_nmul_iff.1 h with ⟨e, he, c', hc, H₁⟩
+    rcases lt_nmul_iff.1 he with ⟨a', ha, b', hb, H₂⟩
+    refine' ⟨a', ha, b', hb, c', hc, _⟩
+    have := nadd_le_nadd H₁ (nmul_nadd_le H₂ hc.le)
+    simp only [nadd_nmul, nadd_assoc] at this
+    rw [nadd_left_comm, nadd_left_comm d, nadd_left_comm, nadd_le_nadd_iff_left,
+      nadd_left_comm (a ⨳ b' ⨳ c), nadd_left_comm (a' ⨳ b ⨳ c), nadd_left_comm (a ⨳ b ⨳ c'),
+      nadd_le_nadd_iff_left, nadd_left_comm (a ⨳ b ⨳ c'), nadd_left_comm (a ⨳ b ⨳ c')] at this
+    simpa only [nadd_assoc]
+  · rintro ⟨a', ha, b', hb, c', hc, h⟩
+    have := h.trans_lt (nmul_nadd_lt₃ ha hb hc)
+    repeat' rw [nadd_lt_nadd_iff_right] at this
+    assumption
+#align ordinal.lt_nmul_iff₃ Ordinal.lt_nmul_iff₃
+
+theorem nmul_le_iff₃ :
+    a ⨳ b ⨳ c ≤ d ↔
+      ∀ a' < a, ∀ b' < b, ∀ c' < c,
+        a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' <
+          d ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c' := by
+  rw [← not_iff_not]; simp [lt_nmul_iff₃]
+#align ordinal.nmul_le_iff₃ Ordinal.nmul_le_iff₃
+
+theorem lt_nmul_iff₃' :
+    d < a ⨳ (b ⨳ c) ↔
+      ∃ a' < a, ∃ b' < b, ∃ c' < c,
+        d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') ≤
+          a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') := by
+  simp only [nmul_comm _ (_ ⨳ _), lt_nmul_iff₃, nadd_eq_add, NatOrdinal.toOrdinal_toNatOrdinal]
+  constructor <;> rintro ⟨b', hb, c', hc, a', ha, h⟩
+  · use a', ha, b', hb, c', hc; convert h using 1 <;> abel_nf
+  · use c', hc, a', ha, b', hb; convert h using 1 <;> abel_nf
+#align ordinal.lt_nmul_iff₃' Ordinal.lt_nmul_iff₃'
+
+theorem nmul_le_iff₃' :
+    a ⨳ (b ⨳ c) ≤ d ↔
+      ∀ a' < a, ∀ b' < b, ∀ c' < c,
+        a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
+          d ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c') := by
+  rw [← not_iff_not]; simp [lt_nmul_iff₃']
+#align ordinal.nmul_le_iff₃' Ordinal.nmul_le_iff₃'
+
+theorem nmul_assoc : ∀ a b c, a ⨳ b ⨳ c = a ⨳ (b ⨳ c)
+  | a, b, c => by
+    apply le_antisymm
+    · rw [nmul_le_iff₃]
+      intro a' ha b' hb c' hc
+      -- Porting note: the next line was just
+      -- repeat' rw [nmul_assoc]
+      -- but we need to spell out the arguments for the termination checker.
+      rw [nmul_assoc a' b c, nmul_assoc a b' c, nmul_assoc a b c', nmul_assoc a' b' c',
+        nmul_assoc a' b' c, nmul_assoc a' b c', nmul_assoc a b' c']
+      exact nmul_nadd_lt₃' ha hb hc
+    · rw [nmul_le_iff₃']
+      intro a' ha b' hb c' hc
+      -- Porting note: the next line was just
+      -- repeat' rw [← nmul_assoc]
+      -- but we need to spell out the arguments for the termination checker.
+      rw [← nmul_assoc a' b c, ← nmul_assoc a b' c, ← nmul_assoc a b c', ← nmul_assoc a' b' c',
+        ← nmul_assoc a' b' c, ← nmul_assoc a' b c', ← nmul_assoc a b' c']
+      exact nmul_nadd_lt₃ ha hb hc
+termination_by nmul_assoc a b c => (a, b, c)
+#align ordinal.nmul_assoc Ordinal.nmul_assoc
+
+end Ordinal
+
+open Ordinal
+
+instance : Mul NatOrdinal :=
+  ⟨nmul⟩
+
+-- Porting note: had to add universe annotations to ensure that the
+-- two sources lived in the same universe.
+instance : OrderedCommSemiring NatOrdinal.{u} :=
+  { NatOrdinal.orderedCancelAddCommMonoid.{u},
+    NatOrdinal.linearOrder.{u} with
+    mul := (· * ·)
+    left_distrib := nmul_nadd
+    right_distrib := nadd_nmul
+    zero_mul := zero_nmul
+    mul_zero := nmul_zero
+    mul_assoc := nmul_assoc
+    one := 1
+    one_mul := one_nmul
+    mul_one := nmul_one
+    mul_comm := nmul_comm
+    zero_le_one := @zero_le_one Ordinal _ _ _ _
+    mul_le_mul_of_nonneg_left := fun a b c => nmul_le_nmul_of_nonneg_left
+    mul_le_mul_of_nonneg_right := fun a b c => nmul_le_nmul_of_nonneg_right }
+
+namespace Ordinal
+
+theorem nmul_eq_mul (a b) : a ⨳ b = toOrdinal (toNatOrdinal a * toNatOrdinal b) :=
+  rfl
+#align ordinal.nmul_eq_mul Ordinal.nmul_eq_mul
+
+theorem nmul_nadd_one : ∀ a b, a ⨳ (b ♯ 1) = a ⨳ b ♯ a :=
+  @mul_add_one NatOrdinal _ _ _
+#align ordinal.nmul_nadd_one Ordinal.nmul_nadd_one
+
+theorem nadd_one_nmul : ∀ a b, (a ♯ 1) ⨳ b = a ⨳ b ♯ b :=
+  @add_one_mul NatOrdinal _ _ _
+#align ordinal.nadd_one_nmul Ordinal.nadd_one_nmul
+
+theorem nmul_succ (a b) : a ⨳ succ b = a ⨳ b ♯ a := by rw [← nadd_one, nmul_nadd_one]
+#align ordinal.nmul_succ Ordinal.nmul_succ
+
+theorem succ_nmul (a b) : succ a ⨳ b = a ⨳ b ♯ b := by rw [← nadd_one, nadd_one_nmul]
+#align ordinal.succ_nmul Ordinal.succ_nmul
+
+theorem nmul_add_one : ∀ a b, a ⨳ (b + 1) = a ⨳ b ♯ a :=
+  nmul_succ
+#align ordinal.nmul_add_one Ordinal.nmul_add_one
+
+theorem add_one_nmul : ∀ a b, (a + 1) ⨳ b = a ⨳ b ♯ b :=
+  succ_nmul
+#align ordinal.add_one_nmul Ordinal.add_one_nmul
+
 end Ordinal
+
+namespace NatOrdinal
+
+open Ordinal
+
+theorem mul_le_nmul (a b : Ordinal.{u}) : a * b ≤ a ⨳ b := by
+  refine b.limitRecOn ?_ ?_ ?_
+  · simp
+  · intro c h
+    rw [mul_succ, nmul_succ]
+    exact (add_le_nadd _ a).trans (nadd_le_nadd_right h a)
+  · intro c hc H
+    rcases eq_zero_or_pos a with (rfl | ha)
+    · simp
+    · -- Porting note: `this` was inline in the `rw`, but now needs a preliminary `dsimp at this`.
+      have := IsNormal.blsub_eq.{u, u} (mul_isNormal ha) hc
+      dsimp at this
+      rw [← this, blsub_le_iff]
+      exact fun i hi => (H i hi).trans_lt (nmul_lt_nmul_of_pos_left hi ha)
+#align nat_ordinal.mul_le_nmul NatOrdinal.mul_le_nmul
+
+end NatOrdinal

chore: partial forward port of 14324 (#5954)

This doesn't yet forward port the changes to Mathlib/SetTheory/Ordinal/NaturalOps.lean.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

f49a8091

Diff

@@ -9,6 +9,7 @@ Authors: Violeta Hernández Palacios
 ! if you have ported upstream changes.
 -/
 import Mathlib.SetTheory.Ordinal.Arithmetic
+import Mathlib.Tactic.Abel
 
 /-!
 # Natural operations on ordinals
@@ -39,7 +40,6 @@ between both types, we attempt to prove and state most results on `Ordinal`.
 
 # Todo
 
-- Define natural multiplication and provide a basic API.
 - Prove the characterizations of natural addition and multiplication in terms of the Cantor normal
   form.
 -/
@@ -51,6 +51,8 @@ open Function Order
 
 noncomputable section
 
+/-! ### Basic casts between `ordinal` and `nat_ordinal` -/
+
 /-- A type synonym for ordinals with natural addition and multiplication. -/
 def NatOrdinal : Type _ :=
   -- porting note: used to derive LinearOrder & SuccOrder but need to manually define
@@ -73,10 +75,10 @@ def NatOrdinal.toOrdinal : NatOrdinal ≃o Ordinal :=
   OrderIso.refl _
 #align nat_ordinal.to_ordinal NatOrdinal.toOrdinal
 
-open Ordinal
-
 namespace NatOrdinal
 
+open Ordinal
+
 variable {a b c : NatOrdinal.{u}}
 
 @[simp]

chore: bump to nightly-2023-07-01 (#5409)

depends on: https://github.com/leanprover/std4/pull/163
depends on: #5584
depends on: #5715
depends on: #5729
depends on: https://github.com/leanprover/std4/pull/173

Co-authored-by: Komyyy <pol_tta@outlook.jp> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

906f7221

Diff

@@ -323,11 +323,11 @@ theorem nat_nadd (n : ℕ) : ↑n ♯ a = a + n := by rw [nadd_comm, nadd_nat]
 #align ordinal.nat_nadd Ordinal.nat_nadd
 
 theorem add_le_nadd : a + b ≤ a ♯ b := by
-  apply b.limitRecOn
-  · simp
-  · intro c h
+  induction b using limitRecOn with
+  | H₁ => simp
+  | H₂ c h =>
     rwa [add_succ, nadd_succ, succ_le_succ_iff]
-  · intro c hc H
+  | H₃ c hc H =>
     simp_rw [← IsNormal.blsub_eq.{u, u} (add_isNormal a) hc, blsub_le_iff]
     exact fun i hi => (H i hi).trans_lt (nadd_lt_nadd_left hi a)
 #align ordinal.add_le_nadd Ordinal.add_le_nadd

chore: remove legacy termination_by' (#5426)

This adds a couple of WellFoundedRelation instances, like for example WellFoundedRelation (WithBot Nat). Longer-term, we should probably add a WellFoundedOrder class for types with a well-founded less-than relation and a [WellFoundOrder α] : WellFoundedRelation α instance (or maybe just [LT α] [IsWellFounded fun a b : α => a < b] : WellFoundedRelation α).

ceb42c50

Diff

@@ -270,15 +270,14 @@ theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
     apply mem_brange_self
 #align ordinal.blsub_nadd_of_mono Ordinal.blsub_nadd_of_mono
 
-theorem nadd_assoc : ∀ a b c, a ♯ b ♯ c = a ♯ (b ♯ c)
-  | a, b, c => by
-    rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
-    · congr <;> ext (d hd) <;> apply nadd_assoc
-    · exact fun  _ _ h => nadd_le_nadd_left h a
-    · exact fun  _ _ h => nadd_le_nadd_right h c
-    termination_by' PSigma.lex (inferInstance) (fun _ ↦ inferInstance)
-    -- Porting note: above lines replaces
-    -- decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
+theorem nadd_assoc (a b c) : a ♯ b ♯ c = a ♯ (b ♯ c) := by
+  rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
+  · congr <;> ext (d hd) <;> apply nadd_assoc
+  · exact fun  _ _ h => nadd_le_nadd_left h a
+  · exact fun  _ _ h => nadd_le_nadd_right h c
+termination_by _ => (a, b, c)
+-- Porting note: above lines replaces
+-- decreasing_by solve_by_elim [PSigma.Lex.left, PSigma.Lex.right]
 #align ordinal.nadd_assoc Ordinal.nadd_assoc
 
 @[simp]

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -181,7 +181,7 @@ theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 :=
 #align ordinal.to_nat_ordinal_eq_one Ordinal.toNatOrdinal_eq_one
 
 @[simp]
-theorem toNatOrdinal_max : toNatOrdinal (max a b) = max (toNatOrdinal a) (toNatOrdinal b ):=
+theorem toNatOrdinal_max : toNatOrdinal (max a b) = max (toNatOrdinal a) (toNatOrdinal b ) :=
   rfl
 #align ordinal.to_nat_ordinal_max Ordinal.toNatOrdinal_max

feat: add Mathlib.Tactic.Common, and import (#4056)

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

a4eaf1c4

Diff

@@ -9,7 +9,7 @@ Authors: Violeta Hernández Palacios
 ! if you have ported upstream changes.
 -/
 import Mathlib.SetTheory.Ordinal.Arithmetic
-import Mathlib.Tactic.SolveByElim
+
 /-!
 # Natural operations on ordinals

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -271,8 +271,7 @@ theorem blsub_nadd_of_mono {f : ∀ c < a ♯ b, Ordinal.{max u v}}
 #align ordinal.blsub_nadd_of_mono Ordinal.blsub_nadd_of_mono
 
 theorem nadd_assoc : ∀ a b c, a ♯ b ♯ c = a ♯ (b ♯ c)
-  | a, b, c =>
-    by
+  | a, b, c => by
     rw [nadd_def a (b ♯ c), nadd_def, blsub_nadd_of_mono, blsub_nadd_of_mono, max_assoc]
     · congr <;> ext (d hd) <;> apply nadd_assoc
     · exact fun  _ _ h => nadd_le_nadd_left h a

feat: tactic congr! and improvement to convert (#2566)

This introduces a tactic congr! that is an analogue to mathlib 3's congr'. It is a more insistent version of congr that makes use of more congruence lemmas (including user congruence lemmas), propext, funext, and Subsingleton instances. It also has a feature to lift reflexive relations to equalities. Along with funext, the tactic does intros, allowing congr! to get access to function bodies; the introduced variables can be named using rename_i if needed.

This also modifies convert to use congr! rather than congr, which makes it work more like the mathlib3 version of the tactic.

b46c2e36

Diff

@@ -287,7 +287,7 @@ theorem nadd_zero : a ♯ 0 = a := by
   induction' a using Ordinal.induction with a IH
   rw [nadd_def, blsub_zero, max_zero_right]
   convert blsub_id a
-  ext (b hb)
+  rename_i hb
   exact IH _ hb
 #align ordinal.nadd_zero Ordinal.nadd_zero