File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

full_name: NatOrdinal
code: /-- A type synonym for ordinals with natural addition and multiplication. -/
def NatOrdinal : Type _ 
goal: Type (u_1 + 1)

full_name: NatOrdinal.linearOrder
code: instance NatOrdinal.linearOrder : LinearOrder NatOrdinal 
goal: LinearOrder NatOrdinal

full_name: NatOrdinal.succOrder
code: instance NatOrdinal.succOrder : SuccOrder NatOrdinal 
goal: SuccOrder NatOrdinal

full_name: Ordinal.toNatOrdinal
code: /-- The identity function between `Ordinal` and `NatOrdinal`. -/
@[match_pattern]
def Ordinal.toNatOrdinal : Ordinal ≃o NatOrdinal 
goal: Ordinal.{u_1} ≃o NatOrdinal

full_name: NatOrdinal.toOrdinal
code: /-- The identity function between `NatOrdinal` and `Ordinal`. -/
@[match_pattern]
def NatOrdinal.toOrdinal : NatOrdinal ≃o Ordinal 
goal: NatOrdinal ≃o Ordinal.{u_1}

full_name: NatOrdinal.toOrdinal_symm_eq
code: @[simp]
theorem toOrdinal_symm_eq : NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal 
goal: NatOrdinal.toOrdinal.symm = Ordinal.toNatOrdinal

full_name: NatOrdinal.toOrdinal_toNatOrdinal
code: @[simp]
theorem toOrdinal_toNatOrdinal (a : NatOrdinal) :
    Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a) = a 
goal: Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a) = a

full_name: NatOrdinal.lt_wf
code: theorem lt_wf : @WellFounded NatOrdinal (· < ·) 
goal: WellFounded fun x x_1 => x < x_1

full_name: NatOrdinal.instWellFoundedLT
code: instance : WellFoundedLT NatOrdinal 
goal: WellFoundedLT NatOrdinal

full_name: NatOrdinal.instIsWellOrderLt
code: instance : IsWellOrder NatOrdinal (· < ·) 
goal: IsWellOrder NatOrdinal fun x x_1 => x < x_1

full_name: NatOrdinal.toOrdinal_zero
code: @[simp]
theorem toOrdinal_zero : toOrdinal 0 = 0 
goal: NatOrdinal.toOrdinal 0 = 0

full_name: NatOrdinal.toOrdinal_one
code: @[simp]
theorem toOrdinal_one : toOrdinal 1 = 1 
goal: NatOrdinal.toOrdinal 1 = 1

full_name: NatOrdinal.toOrdinal_eq_zero
code: @[simp]
theorem toOrdinal_eq_zero (a) : toOrdinal a = 0 ↔ a = 0 
goal: NatOrdinal.toOrdinal a = 0 ↔ a = 0

full_name: NatOrdinal.toOrdinal_eq_one
code: @[simp]
theorem toOrdinal_eq_one (a) : toOrdinal a = 1 ↔ a = 1 
goal: NatOrdinal.toOrdinal a = 1 ↔ a = 1

full_name: NatOrdinal.toOrdinal_max
code: @[simp]
theorem toOrdinal_max {a b : NatOrdinal} : toOrdinal (max a b) = max (toOrdinal a) (toOrdinal b) 
goal: NatOrdinal.toOrdinal (max a b) = max (NatOrdinal.toOrdinal a) (NatOrdinal.toOrdinal b)

full_name: NatOrdinal.toOrdinal_min
code: @[simp]
theorem toOrdinal_min {a b : NatOrdinal} : toOrdinal (min a b) = min (toOrdinal a) (toOrdinal b) 
goal: NatOrdinal.toOrdinal (min a b) = min (NatOrdinal.toOrdinal a) (NatOrdinal.toOrdinal b)

full_name: NatOrdinal.succ_def
code: theorem succ_def (a : NatOrdinal) : succ a = toNatOrdinal (toOrdinal a + 1) 
goal: Order.succ a = Ordinal.toNatOrdinal (NatOrdinal.toOrdinal a + 1)

full_name: NatOrdinal.rec
code: /-- A recursor for `NatOrdinal`. Use as `induction x`. -/
@[elab_as_elim, cases_eliminator, induction_eliminator]
protected def rec {β : NatOrdinal → Sort*} (h : ∀ a, β (toNatOrdinal a)) : ∀ a, β a 
goal: β a

full_name: NatOrdinal.induction
code: /-- `Ordinal.induction` but for `NatOrdinal`. -/
theorem induction {p : NatOrdinal → Prop} : ∀ (i) (_ : ∀ j, (∀ k, k < j → p k) → p j), p i 
goal: (∀ (j : NatOrdinal), (∀ k < j, p k) → p j) → p i

full_name: Ordinal.toNatOrdinal_symm_eq
code: @[simp]
theorem toNatOrdinal_symm_eq : toNatOrdinal.symm = NatOrdinal.toOrdinal 
goal: Ordinal.toNatOrdinal.symm = NatOrdinal.toOrdinal

full_name: Ordinal.toNatOrdinal_toOrdinal
code: @[simp]
theorem toNatOrdinal_toOrdinal (a : Ordinal) :  NatOrdinal.toOrdinal (toNatOrdinal a) = a 
goal: NatOrdinal.toOrdinal (Ordinal.toNatOrdinal a) = a

full_name: Ordinal.toNatOrdinal_zero
code: @[simp]
theorem toNatOrdinal_zero : toNatOrdinal 0 = 0 
goal: Ordinal.toNatOrdinal 0 = 0

full_name: Ordinal.toNatOrdinal_one
code: @[simp]
theorem toNatOrdinal_one : toNatOrdinal 1 = 1 
goal: Ordinal.toNatOrdinal 1 = 1

full_name: Ordinal.toNatOrdinal_eq_zero
code: @[simp]
theorem toNatOrdinal_eq_zero (a) : toNatOrdinal a = 0 ↔ a = 0 
goal: Ordinal.toNatOrdinal a = 0 ↔ a = 0

full_name: Ordinal.toNatOrdinal_eq_one
code: @[simp]
theorem toNatOrdinal_eq_one (a) : toNatOrdinal a = 1 ↔ a = 1 
goal: Ordinal.toNatOrdinal a = 1 ↔ a = 1

full_name: Ordinal.toNatOrdinal_max
code: @[simp]
theorem toNatOrdinal_max (a b : Ordinal) :
    toNatOrdinal (max a b) = max (toNatOrdinal a) (toNatOrdinal b) 
goal: Ordinal.toNatOrdinal (max a b) = max (Ordinal.toNatOrdinal a) (Ordinal.toNatOrdinal b)

full_name: Ordinal.toNatOrdinal_min
code: @[simp]
theorem toNatOrdinal_min (a b : Ordinal) :
    toNatOrdinal (linearOrder.min a b) = linearOrder.min (toNatOrdinal a) (toNatOrdinal b) 
goal: Ordinal.toNatOrdinal (min a b) = min (Ordinal.toNatOrdinal a) (Ordinal.toNatOrdinal b)

full_name: Ordinal.nadd
code: /-- 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.

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
  
goal: Ordinal.{u} → Ordinal.{u} → Ordinal.{u}

full_name: NaturalOps.«_aux_Mathlib_SetTheory_Ordinal_NaturalOps___macroRules_NaturalOps_term_♯__1»
code: @[inherit_doc]
scoped[NaturalOps] infixl:65 " ♯ " => Ordinal.nadd
goal: Lean.Macro

full_name: NaturalOps._aux_Mathlib_SetTheory_Ordinal_NaturalOps___unexpand_Ordinal_nadd_1
code: @[inherit_doc]
scoped[NaturalOps] infixl:65 " ♯ " => Ordinal.nadd
goal: Lean.PrettyPrinter.Unexpander

full_name: Ordinal.nmul
code: /-- 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}
  
goal: Ordinal.{u} → Ordinal.{u} → Ordinal.{u}

full_name: NaturalOps._aux_Mathlib_SetTheory_Ordinal_NaturalOps___unexpand_Ordinal_nmul_1
code: @[inherit_doc]
scoped[NaturalOps] infixl:70 " ⨳ " => Ordinal.nmul
goal: Lean.PrettyPrinter.Unexpander

full_name: NaturalOps.«_aux_Mathlib_SetTheory_Ordinal_NaturalOps___macroRules_NaturalOps_term_⨳__1»
code: @[inherit_doc]
scoped[NaturalOps] infixl:70 " ⨳ " => Ordinal.nmul
goal: Lean.Macro

full_name: Ordinal.nadd_def
code: 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') 
goal: a ♯ b = max (a.blsub fun a' x => a' ♯ b) (b.blsub fun b' x => a ♯ b')

full_name: Ordinal.lt_nadd_iff
code: theorem lt_nadd_iff : a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c' 
goal: a < b ♯ c ↔ (∃ b' < b, a ≤ b' ♯ c) ∨ ∃ c' < c, a ≤ b ♯ c'

full_name: Ordinal.nadd_le_iff
code: theorem nadd_le_iff : b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a 
goal: b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a

full_name: Ordinal.nadd_lt_nadd_left
code: theorem nadd_lt_nadd_left (h : b < c) (a) : a ♯ b < a ♯ c 
goal: a ♯ b < a ♯ c

full_name: Ordinal.nadd_lt_nadd_right
code: theorem nadd_lt_nadd_right (h : b < c) (a) : b ♯ a < c ♯ a 
goal: b ♯ a < c ♯ a

full_name: Ordinal.nadd_le_nadd_left
code: theorem nadd_le_nadd_left (h : b ≤ c) (a) : a ♯ b ≤ a ♯ c 
goal: a ♯ b ≤ a ♯ c

full_name: Ordinal.nadd_le_nadd_right
code: theorem nadd_le_nadd_right (h : b ≤ c) (a) : b ♯ a ≤ c ♯ a 
goal: b ♯ a ≤ c ♯ a

full_name: Ordinal.nadd_comm
code: theorem nadd_comm : ∀ a b, a ♯ b = b ♯ a
  
goal: a ♯ b = b ♯ a

full_name: Ordinal.blsub_nadd_of_mono
code: 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) :
    -- Porting note: needed to add universe hint blsub.{u,v} in the line below
    blsub.{u,v} _ f =
      max (blsub.{u, v} a fun a' ha' => f (a' ♯ b) <| nadd_lt_nadd_right ha' b)
        (blsub.{u, v} b fun b' hb' => f (a ♯ b') <| nadd_lt_nadd_left hb' a) 
goal: (a ♯ b).blsub f = max (a.blsub fun a' ha' => f (a' ♯ b) ⋯) (b.blsub fun b' hb' => f (a ♯ b') ⋯)

full_name: Ordinal.nadd_assoc
code: theorem nadd_assoc (a b c) : a ♯ b ♯ c = a ♯ (b ♯ c) 
goal: a ♯ b ♯ c = a ♯ (b ♯ c)

full_name: Ordinal.nadd_zero
code: @[simp]
theorem nadd_zero : a ♯ 0 = a 
goal: a ♯ 0 = a

full_name: Ordinal.zero_nadd
code: @[simp]
theorem zero_nadd : 0 ♯ a = a 
goal: 0 ♯ a = a

full_name: Ordinal.nadd_one
code: @[simp]
theorem nadd_one : a ♯ 1 = succ a 
goal: a ♯ 1 = Order.succ a

full_name: Ordinal.one_nadd
code: @[simp]
theorem one_nadd : 1 ♯ a = succ a 
goal: 1 ♯ a = Order.succ a

full_name: Ordinal.nadd_succ
code: theorem nadd_succ : a ♯ succ b = succ (a ♯ b) 
goal: a ♯ Order.succ b = Order.succ (a ♯ b)

full_name: Ordinal.succ_nadd
code: theorem succ_nadd : succ a ♯ b = succ (a ♯ b) 
goal: Order.succ a ♯ b = Order.succ (a ♯ b)

full_name: Ordinal.nadd_nat
code: @[simp]
theorem nadd_nat (n : ℕ) : a ♯ n = a + n 
goal: a ♯ ↑n = a + ↑n

full_name: Ordinal.nat_nadd
code: @[simp]
theorem nat_nadd (n : ℕ) : ↑n ♯ a = a + n 
goal: ↑n ♯ a = a + ↑n

full_name: Ordinal.add_le_nadd
code: theorem add_le_nadd : a + b ≤ a ♯ b 
goal: a + b ≤ a ♯ b

full_name: NatOrdinal.instAdd
code: instance : Add NatOrdinal 
goal: Add NatOrdinal

full_name: NatOrdinal.add_covariantClass_lt
code: instance add_covariantClass_lt : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· < ·) 
goal: CovariantClass NatOrdinal NatOrdinal (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: NatOrdinal.add_covariantClass_le
code: instance add_covariantClass_le : CovariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) 
goal: CovariantClass NatOrdinal NatOrdinal (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: NatOrdinal.add_contravariantClass_le
code: instance add_contravariantClass_le :
    ContravariantClass NatOrdinal.{u} NatOrdinal.{u} (· + ·) (· ≤ ·) 
goal: ContravariantClass NatOrdinal NatOrdinal (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: NatOrdinal.orderedCancelAddCommMonoid
code: instance orderedCancelAddCommMonoid : OrderedCancelAddCommMonoid NatOrdinal 
goal: OrderedCancelAddCommMonoid NatOrdinal

full_name: NatOrdinal.addMonoidWithOne
code: instance addMonoidWithOne : AddMonoidWithOne NatOrdinal 
goal: AddMonoidWithOne NatOrdinal

full_name: NatOrdinal.add_one_eq_succ
code: @[simp]
theorem add_one_eq_succ : ∀ a : NatOrdinal, a + 1 = succ a 
goal: a + 1 = Order.succ a

full_name: NatOrdinal.toOrdinal_cast_nat
code: @[simp]
theorem toOrdinal_cast_nat (n : ℕ) : toOrdinal n = n 
goal: NatOrdinal.toOrdinal ↑n = ↑n

full_name: Ordinal.nadd_eq_add
code: theorem nadd_eq_add (a b : Ordinal) : a ♯ b = toOrdinal (toNatOrdinal a + toNatOrdinal b) 
goal: a ♯ b = NatOrdinal.toOrdinal (Ordinal.toNatOrdinal a + Ordinal.toNatOrdinal b)

full_name: Ordinal.toNatOrdinal_cast_nat
code: @[simp]
theorem toNatOrdinal_cast_nat (n : ℕ) : toNatOrdinal n = n 
goal: Ordinal.toNatOrdinal ↑n = ↑n

full_name: Ordinal.lt_of_nadd_lt_nadd_left
code: theorem lt_of_nadd_lt_nadd_left : ∀ {a b c}, a ♯ b < a ♯ c → b < c 
goal: a ♯ b < a ♯ c → b < c

full_name: Ordinal.lt_of_nadd_lt_nadd_right
code: theorem lt_of_nadd_lt_nadd_right : ∀ {a b c}, b ♯ a < c ♯ a → b < c 
goal: b ♯ a < c ♯ a → b < c

full_name: Ordinal.le_of_nadd_le_nadd_left
code: theorem le_of_nadd_le_nadd_left : ∀ {a b c}, a ♯ b ≤ a ♯ c → b ≤ c 
goal: a ♯ b ≤ a ♯ c → b ≤ c

full_name: Ordinal.le_of_nadd_le_nadd_right
code: theorem le_of_nadd_le_nadd_right : ∀ {a b c}, b ♯ a ≤ c ♯ a → b ≤ c 
goal: b ♯ a ≤ c ♯ a → b ≤ c

full_name: Ordinal.nadd_lt_nadd_iff_left
code: theorem nadd_lt_nadd_iff_left : ∀ (a) {b c}, a ♯ b < a ♯ c ↔ b < c 
goal: a ♯ b < a ♯ c ↔ b < c

full_name: Ordinal.nadd_lt_nadd_iff_right
code: theorem nadd_lt_nadd_iff_right : ∀ (a) {b c}, b ♯ a < c ♯ a ↔ b < c 
goal: b ♯ a < c ♯ a ↔ b < c

full_name: Ordinal.nadd_le_nadd_iff_left
code: theorem nadd_le_nadd_iff_left : ∀ (a) {b c}, a ♯ b ≤ a ♯ c ↔ b ≤ c 
goal: a ♯ b ≤ a ♯ c ↔ b ≤ c

full_name: Ordinal.nadd_le_nadd_iff_right
code: theorem nadd_le_nadd_iff_right : ∀ (a) {b c}, b ♯ a ≤ c ♯ a ↔ b ≤ c 
goal: b ♯ a ≤ c ♯ a ↔ b ≤ c

full_name: Ordinal.nadd_le_nadd
code: theorem nadd_le_nadd : ∀ {a b c d}, a ≤ b → c ≤ d → a ♯ c ≤ b ♯ d 
goal: a ≤ b → c ≤ d → a ♯ c ≤ b ♯ d

full_name: Ordinal.nadd_lt_nadd
code: theorem nadd_lt_nadd : ∀ {a b c d}, a < b → c < d → a ♯ c < b ♯ d 
goal: a < b → c < d → a ♯ c < b ♯ d

full_name: Ordinal.nadd_lt_nadd_of_lt_of_le
code: theorem nadd_lt_nadd_of_lt_of_le : ∀ {a b c d}, a < b → c ≤ d → a ♯ c < b ♯ d 
goal: a < b → c ≤ d → a ♯ c < b ♯ d

full_name: Ordinal.nadd_lt_nadd_of_le_of_lt
code: theorem nadd_lt_nadd_of_le_of_lt : ∀ {a b c d}, a ≤ b → c < d → a ♯ c < b ♯ d 
goal: a ≤ b → c < d → a ♯ c < b ♯ d

full_name: Ordinal.nadd_left_cancel
code: theorem nadd_left_cancel : ∀ {a b c}, a ♯ b = a ♯ c → b = c 
goal: a ♯ b = a ♯ c → b = c

full_name: Ordinal.nadd_right_cancel
code: theorem nadd_right_cancel : ∀ {a b c}, a ♯ b = c ♯ b → a = c 
goal: a ♯ b = c ♯ b → a = c

full_name: Ordinal.nadd_left_cancel_iff
code: theorem nadd_left_cancel_iff : ∀ {a b c}, a ♯ b = a ♯ c ↔ b = c 
goal: a ♯ b = a ♯ c ↔ b = c

full_name: Ordinal.nadd_right_cancel_iff
code: theorem nadd_right_cancel_iff : ∀ {a b c}, b ♯ a = c ♯ a ↔ b = c 
goal: b ♯ a = c ♯ a ↔ b = c

full_name: Ordinal.le_nadd_self
code: theorem le_nadd_self {a b} : a ≤ b ♯ a 
goal: a ≤ b ♯ a

full_name: Ordinal.le_nadd_left
code: theorem le_nadd_left {a b c} (h : a ≤ c) : a ≤ b ♯ c 
goal: a ≤ b ♯ c

full_name: Ordinal.le_self_nadd
code: theorem le_self_nadd {a b} : a ≤ a ♯ b 
goal: a ≤ a ♯ b

full_name: Ordinal.le_nadd_right
code: theorem le_nadd_right {a b c} (h : a ≤ b) : a ≤ b ♯ c 
goal: a ≤ b ♯ c

full_name: Ordinal.nadd_left_comm
code: theorem nadd_left_comm : ∀ a b c, a ♯ (b ♯ c) = b ♯ (a ♯ c) 
goal: a ♯ (b ♯ c) = b ♯ (a ♯ c)

full_name: Ordinal.nadd_right_comm
code: theorem nadd_right_comm : ∀ a b c, a ♯ b ♯ c = a ♯ c ♯ b 
goal: a ♯ b ♯ c = a ♯ c ♯ b

full_name: Ordinal.nmul_def
code: theorem nmul_def (a b : Ordinal) :
    a ⨳ b = sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'} 
goal: a ⨳ b = sInf {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}

full_name: Ordinal.nmul_nonempty
code: /-- 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 
goal: {c | ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'}.Nonempty

full_name: Ordinal.nmul_nadd_lt
code: theorem nmul_nadd_lt {a' b' : Ordinal} (ha : a' < a) (hb : b' < b) :
    a' ⨳ b ♯ a ⨳ b' < a ⨳ b ♯ a' ⨳ b' 
goal: a' ⨳ b ♯ a ⨳ b' < a ⨳ b ♯ a' ⨳ b'

full_name: Ordinal.nmul_nadd_le
code: theorem nmul_nadd_le {a' b' : Ordinal} (ha : a' ≤ a) (hb : b' ≤ b) :
    a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b' 
goal: a' ⨳ b ♯ a ⨳ b' ≤ a ⨳ b ♯ a' ⨳ b'

full_name: Ordinal.lt_nmul_iff
code: theorem lt_nmul_iff : c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b' 
goal: c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'

full_name: Ordinal.nmul_le_iff
code: theorem nmul_le_iff : a ⨳ b ≤ c ↔ ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b' 
goal: a ⨳ b ≤ c ↔ ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'

full_name: Ordinal.nmul_comm
code: theorem nmul_comm : ∀ a b, a ⨳ b = b ⨳ a
  
goal: a ⨳ b = b ⨳ a

full_name: Ordinal.nmul_zero
code: @[simp]
theorem nmul_zero (a) : a ⨳ 0 = 0 
goal: a ⨳ 0 = 0

full_name: Ordinal.zero_nmul
code: @[simp]
theorem zero_nmul (a) : 0 ⨳ a = 0 
goal: 0 ⨳ a = 0

full_name: Ordinal.nmul_one
code: @[simp]
theorem nmul_one (a : Ordinal) : a ⨳ 1 = a 
goal: a ⨳ 1 = a

full_name: Ordinal.one_nmul
code: @[simp]
theorem one_nmul (a) : 1 ⨳ a = a 
goal: 1 ⨳ a = a

full_name: Ordinal.nmul_lt_nmul_of_pos_left
code: theorem nmul_lt_nmul_of_pos_left (h₁ : a < b) (h₂ : 0 < c) : c ⨳ a < c ⨳ b 
goal: c ⨳ a < c ⨳ b

full_name: Ordinal.nmul_lt_nmul_of_pos_right
code: theorem nmul_lt_nmul_of_pos_right (h₁ : a < b) (h₂ : 0 < c) : a ⨳ c < b ⨳ c 
goal: a ⨳ c < b ⨳ c

full_name: Ordinal.nmul_le_nmul_of_nonneg_left
code: theorem nmul_le_nmul_of_nonneg_left (h₁ : a ≤ b) (h₂ : 0 ≤ c) : c ⨳ a ≤ c ⨳ b 
goal: c ⨳ a ≤ c ⨳ b

full_name: Ordinal.nmul_le_nmul_of_nonneg_right
code: theorem nmul_le_nmul_of_nonneg_right (h₁ : a ≤ b) (h₂ : 0 ≤ c) : a ⨳ c ≤ b ⨳ c 
goal: a ⨳ c ≤ b ⨳ c

full_name: Ordinal.nmul_nadd
code: theorem nmul_nadd : ∀ a b c, a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c
  
goal: a ⨳ (b ♯ c) = a ⨳ b ♯ a ⨳ c

full_name: Ordinal.nadd_nmul
code: theorem nadd_nmul (a b c) : (a ♯ b) ⨳ c = a ⨳ c ♯ b ⨳ c 
goal: (a ♯ b) ⨳ c = a ⨳ c ♯ b ⨳ c

full_name: Ordinal.nmul_nadd_lt₃
code: 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' 
goal: a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' < a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c'

full_name: Ordinal.nmul_nadd_le₃
code: 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' 
goal: a' ⨳ b ⨳ c ♯ a ⨳ b' ⨳ c ♯ a ⨳ b ⨳ c' ♯ a' ⨳ b' ⨳ c' ≤ a ⨳ b ⨳ c ♯ a' ⨳ b' ⨳ c ♯ a' ⨳ b ⨳ c' ♯ a ⨳ b' ⨳ c'

full_name: Ordinal.nmul_nadd_lt₃'
code: 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') 
goal: a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
  a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c')

full_name: Ordinal.nmul_nadd_le₃'
code: 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') 
goal: a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') ≤
  a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c')

full_name: Ordinal.lt_nmul_iff₃
code: 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' 
goal: 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'

full_name: Ordinal.nmul_le_iff₃
code: 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' 
goal: 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'

full_name: Ordinal.lt_nmul_iff₃'
code: 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') 
goal: 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')

full_name: Ordinal.nmul_le_iff₃'
code: 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') 
goal: 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')

full_name: Ordinal.nmul_assoc
code: theorem nmul_assoc : ∀ a b c, a ⨳ b ⨳ c = a ⨳ (b ⨳ c)
  
goal: a ⨳ b ⨳ c = a ⨳ (b ⨳ c)

full_name: instMulNatOrdinal
code: instance : Mul NatOrdinal 
goal: Mul NatOrdinal

full_name: instOrderedCommSemiringNatOrdinal
code: instance : OrderedCommSemiring NatOrdinal.{u} 
goal: OrderedCommSemiring NatOrdinal

full_name: Ordinal.nmul_eq_mul
code: theorem nmul_eq_mul (a b) : a ⨳ b = toOrdinal (toNatOrdinal a * toNatOrdinal b) 
goal: a ⨳ b = NatOrdinal.toOrdinal (Ordinal.toNatOrdinal a * Ordinal.toNatOrdinal b)

full_name: Ordinal.nmul_nadd_one
code: theorem nmul_nadd_one : ∀ a b, a ⨳ (b ♯ 1) = a ⨳ b ♯ a 
goal: a ⨳ (b ♯ 1) = a ⨳ b ♯ a

full_name: Ordinal.nadd_one_nmul
code: theorem nadd_one_nmul : ∀ a b, (a ♯ 1) ⨳ b = a ⨳ b ♯ b 
goal: (a ♯ 1) ⨳ b = a ⨳ b ♯ b

full_name: Ordinal.nmul_succ
code: theorem nmul_succ (a b) : a ⨳ succ b = a ⨳ b ♯ a 
goal: a ⨳ Order.succ b = a ⨳ b ♯ a

full_name: Ordinal.succ_nmul
code: theorem succ_nmul (a b) : succ a ⨳ b = a ⨳ b ♯ b 
goal: Order.succ a ⨳ b = a ⨳ b ♯ b

full_name: Ordinal.nmul_add_one
code: theorem nmul_add_one : ∀ a b, a ⨳ (b + 1) = a ⨳ b ♯ a 
goal: a ⨳ (b + 1) = a ⨳ b ♯ a

full_name: Ordinal.add_one_nmul
code: theorem add_one_nmul : ∀ a b, (a + 1) ⨳ b = a ⨳ b ♯ b 
goal: (a + 1) ⨳ b = a ⨳ b ♯ b

full_name: NatOrdinal.mul_le_nmul
code: theorem mul_le_nmul (a b : Ordinal.{u}) : a * b ≤ a ⨳ b 
goal: a * b ≤ a ⨳ b