fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
succ_pred_eq_iff_not_isSuccPrelimit {o} : succ (pred o) = o ↔ ¬ IsSuccPrelimit o := by
rw [← (self_le_succ_pred o).ge_iff_eq', succ_le_iff, pred_lt_iff_not_isSuccPrelimit]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | succ_pred_eq_iff_not_isSuccPrelimit | null |
lift_pred (o : Ordinal.{v}) : lift.{u} (pred o) = pred (lift.{u} o) := by
obtain ⟨a, rfl⟩ | ho := mem_range_succ_or_isSuccPrelimit o
· simp
· rwa [ho.ordinalPred_eq, eq_comm, pred_eq_iff_isSuccPrelimit, isSuccPrelimit_lift]
/-! ### Normal ordinal functions -/ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lift_pred | null |
IsNormal (f : Ordinal → Ordinal) : Prop :=
Order.IsNormal f | def | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal | A normal ordinal function is a strictly increasing function which is
order-continuous, i.e., the image `f o` of a limit ordinal `o` is the sup of `f a` for
`a < o`.
Todo: deprecate this in favor of `Order.IsNormal`. |
IsNormal.limit_le {f} (H : IsNormal f) :
∀ {o}, IsSuccLimit o → ∀ {a}, f o ≤ a ↔ ∀ b < o, f b ≤ a :=
H.le_iff_forall_le | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.limit_le | null |
IsNormal.limit_lt {f} (H : IsNormal f) {o} (h : IsSuccLimit o) {a} :
a < f o ↔ ∃ b < o, a < f b :=
H.lt_iff_exists_lt h | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.limit_lt | null |
IsNormal.strictMono {f} (H : IsNormal f) : StrictMono f :=
Order.IsNormal.strictMono H | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.strictMono | null |
IsNormal.monotone {f} (H : IsNormal f) : Monotone f :=
H.strictMono.monotone | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.monotone | null |
isNormal_iff_strictMono_limit (f : Ordinal → Ordinal) :
IsNormal f ↔ StrictMono f ∧ ∀ o, IsSuccLimit o → ∀ a, (∀ b < o, f b ≤ a) → f o ≤ a :=
isNormal_iff | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isNormal_iff_strictMono_limit | null |
IsNormal.lt_iff {f} (H : IsNormal f) {a b} : f a < f b ↔ a < b :=
StrictMono.lt_iff_lt <| H.strictMono | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.lt_iff | null |
IsNormal.le_iff {f} (H : IsNormal f) {a b} : f a ≤ f b ↔ a ≤ b :=
le_iff_le_iff_lt_iff_lt.2 H.lt_iff | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.le_iff | null |
IsNormal.inj {f} (H : IsNormal f) {a b} : f a = f b ↔ a = b := by
simp only [le_antisymm_iff, H.le_iff] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.inj | null |
IsNormal.id_le {f} (H : IsNormal f) : id ≤ f :=
H.strictMono.id_le | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.id_le | null |
IsNormal.le_apply {f} (H : IsNormal f) {a} : a ≤ f a :=
H.strictMono.le_apply | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.le_apply | null |
IsNormal.le_iff_eq {f} (H : IsNormal f) {a} : f a ≤ a ↔ f a = a :=
H.le_apply.ge_iff_eq' | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.le_iff_eq | null |
IsNormal.le_set {f o} (H : IsNormal f) (p : Set Ordinal) (p0 : p.Nonempty) (b)
(H₂ : ∀ o, b ≤ o ↔ ∀ a ∈ p, a ≤ o) : f b ≤ o ↔ ∀ a ∈ p, f a ≤ o :=
⟨fun h _ pa => (H.le_iff.2 ((H₂ _).1 le_rfl _ pa)).trans h, fun h => by
induction b using limitRecOn with
| zero =>
obtain ⟨x, px⟩ := p0
have := Ordinal.le_zero.1 ((H₂ _).1 (Ordinal.zero_le _) _ px)
rw [this] at px
exact h _ px
| succ S _ =>
rcases not_forall₂.1 (mt (H₂ S).2 <| (lt_succ S).not_ge) with ⟨a, h₁, h₂⟩
exact (H.le_iff.2 <| succ_le_of_lt <| not_le.1 h₂).trans (h _ h₁)
| limit S L _ =>
refine (H.le_iff_forall_le L).2 fun a h' => ?_
rcases not_forall₂.1 (mt (H₂ a).2 h'.not_ge) with ⟨b, h₁, h₂⟩
exact (H.le_iff.2 <| (not_le.1 h₂).le).trans (h _ h₁)⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.le_set | null |
IsNormal.le_set' {f o} (H : IsNormal f) (p : Set α) (p0 : p.Nonempty) (g : α → Ordinal) (b)
(H₂ : ∀ o, b ≤ o ↔ ∀ a ∈ p, g a ≤ o) : f b ≤ o ↔ ∀ a ∈ p, f (g a) ≤ o := by
simpa [H₂] using H.le_set (g '' p) (p0.image g) b | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.le_set' | null |
IsNormal.refl : IsNormal id :=
.id | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.refl | null |
IsNormal.trans {f g} (H₁ : IsNormal f) (H₂ : IsNormal g) : IsNormal (f ∘ g) :=
H₁.comp H₂ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.trans | null |
IsNormal.isSuccLimit {f} (H : IsNormal f) {o} (ho : IsSuccLimit o) : IsSuccLimit (f o) :=
H.map_isSuccLimit ho
/-! ### Subtraction on ordinals -/ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | IsNormal.isSuccLimit | null |
existsAddOfLE : ExistsAddOfLE Ordinal where
exists_add_of_le {a b} := by
refine inductionOn₂ a b fun α r _ β s _ ⟨f⟩ ↦ ?_
obtain ⟨γ, t, _, ⟨g⟩⟩ := f.exists_sum_relIso
exact ⟨type t, g.ordinal_type_eq.symm⟩ | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | existsAddOfLE | null |
canonicallyOrderedAdd : CanonicallyOrderedAdd Ordinal where
le_add_self := le_add_left
le_self_add := le_add_right | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | canonicallyOrderedAdd | null |
sub : Sub Ordinal where
sub a b := if h : b ≤ a then Classical.choose (exists_add_of_le h) else 0 | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub | `a - b` is the unique ordinal satisfying `b + (a - b) = a` when `b ≤ a`. |
private sub_eq_zero_of_lt {a b : Ordinal} (h : a < b) : a - b = 0 :=
dif_neg h.not_ge | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_eq_zero_of_lt | null |
protected add_sub_cancel_of_le {a b : Ordinal} (h : b ≤ a) : b + (a - b) = a := by
change b + dite _ _ _ = a
rw [dif_pos h]
exact (Classical.choose_spec (exists_add_of_le h)).symm
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_sub_cancel_of_le | null |
add_sub_cancel (a b : Ordinal) : a + b - a = b := by
simpa using Ordinal.add_sub_cancel_of_le (le_add_right a b) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_sub_cancel | null |
le_add_sub (a b : Ordinal) : a ≤ b + (a - b) := by
obtain h | h := le_or_gt b a
· exact (Ordinal.add_sub_cancel_of_le h).ge
· simpa [sub_eq_zero_of_lt h] using h.le | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | le_add_sub | null |
sub_le {a b c : Ordinal} : a - b ≤ c ↔ a ≤ b + c := by
refine ⟨fun h ↦ (le_add_sub a b).trans (add_le_add_left h _), fun h ↦ ?_⟩
obtain h' | h' := le_or_gt b a
· rwa [← add_le_add_iff_left b, Ordinal.add_sub_cancel_of_le h']
· simp [sub_eq_zero_of_lt h'] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_le | null |
lt_sub {a b c : Ordinal} : a < b - c ↔ c + a < b :=
lt_iff_lt_of_le_iff_le sub_le | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lt_sub | null |
sub_eq_of_add_eq {a b c : Ordinal} (h : a + b = c) : c - a = b :=
h ▸ add_sub_cancel _ _ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_eq_of_add_eq | null |
sub_le_self (a b : Ordinal) : a - b ≤ a :=
sub_le.2 <| le_add_left _ _ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_le_self | null |
le_sub_of_le {a b c : Ordinal} (h : b ≤ a) : c ≤ a - b ↔ b + c ≤ a := by
rw [← add_le_add_iff_left b, Ordinal.add_sub_cancel_of_le h] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | le_sub_of_le | null |
sub_lt_of_le {a b c : Ordinal} (h : b ≤ a) : a - b < c ↔ a < b + c :=
lt_iff_lt_of_le_iff_le (le_sub_of_le h)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_lt_of_le | null |
sub_zero (a : Ordinal) : a - 0 = a := by simpa only [zero_add] using add_sub_cancel 0 a
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_zero | null |
zero_sub (a : Ordinal) : 0 - a = 0 := by rw [← Ordinal.le_zero]; apply sub_le_self
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | zero_sub | null |
sub_self (a : Ordinal) : a - a = 0 := by simpa only [add_zero] using add_sub_cancel a 0 | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_self | null |
protected sub_eq_zero_iff_le {a b : Ordinal} : a - b = 0 ↔ a ≤ b :=
⟨fun h => by simpa only [h, add_zero] using le_add_sub a b, fun h => by
rwa [← Ordinal.le_zero, sub_le, add_zero]⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_eq_zero_iff_le | null |
protected sub_ne_zero_iff_lt {a b : Ordinal} : a - b ≠ 0 ↔ b < a := by
simpa using Ordinal.sub_eq_zero_iff_le.not | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_ne_zero_iff_lt | null |
sub_sub (a b c : Ordinal) : a - b - c = a - (b + c) :=
eq_of_forall_ge_iff fun d => by rw [sub_le, sub_le, sub_le, add_assoc]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_sub | null |
add_sub_add_cancel (a b c : Ordinal) : a + b - (a + c) = b - c := by
rw [← sub_sub, add_sub_cancel] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_sub_add_cancel | null |
le_sub_of_add_le {a b c : Ordinal} (h : b + c ≤ a) : c ≤ a - b := by
rw [← add_le_add_iff_left b]
exact h.trans (le_add_sub a b) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | le_sub_of_add_le | null |
sub_lt_of_lt_add {a b c : Ordinal} (h : a < b + c) (hc : 0 < c) : a - b < c := by
obtain hab | hba := lt_or_ge a b
· rwa [Ordinal.sub_eq_zero_iff_le.2 hab.le]
· rwa [sub_lt_of_le hba] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | sub_lt_of_lt_add | null |
lt_add_iff {a b c : Ordinal} (hc : c ≠ 0) : a < b + c ↔ ∃ d < c, a ≤ b + d := by
use fun h ↦ ⟨_, sub_lt_of_lt_add h hc.bot_lt, le_add_sub a b⟩
rintro ⟨d, hd, ha⟩
exact ha.trans_lt (add_lt_add_left hd b) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lt_add_iff | null |
add_le_iff {a b c : Ordinal} (hb : b ≠ 0) : a + b ≤ c ↔ ∀ d < b, a + d < c := by
simpa using (lt_add_iff hb).not | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_le_iff | null |
lt_add_iff_of_isSuccLimit {a b c : Ordinal} (hc : IsSuccLimit c) :
a < b + c ↔ ∃ d < c, a < b + d := by
rw [lt_add_iff hc.ne_bot]
constructor <;> rintro ⟨d, hd, ha⟩
· refine ⟨_, hc.succ_lt hd, ?_⟩
rwa [add_succ, lt_succ_iff]
· exact ⟨d, hd, ha.le⟩
@[deprecated (since := "2025-07-08")]
alias lt_add_of_limit := lt_add_iff_of_isSuccLimit | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lt_add_iff_of_isSuccLimit | null |
add_le_iff_of_isSuccLimit {a b c : Ordinal} (hb : IsSuccLimit b) :
a + b ≤ c ↔ ∀ d < b, a + d ≤ c := by
simpa using (lt_add_iff_of_isSuccLimit hb).not
@[deprecated (since := "2025-07-08")]
alias add_le_of_limit := add_le_iff_of_isSuccLimit | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_le_iff_of_isSuccLimit | null |
isNormal_add_right (a : Ordinal) : IsNormal (a + ·) := by
rw [isNormal_iff_strictMono_limit]
exact ⟨add_right_strictMono, fun _ l _ ↦ (add_le_iff_of_isSuccLimit l).2⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isNormal_add_right | null |
isSuccLimit_add (a : Ordinal) {b : Ordinal} : IsSuccLimit b → IsSuccLimit (a + b) :=
(isNormal_add_right a).isSuccLimit
@[deprecated (since := "2025-07-09")]
alias isLimit_add := isSuccLimit_add
@[deprecated (since := "2025-07-09")]
alias IsLimit.add := isSuccLimit_add | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_add | null |
isSuccLimit_sub {a b : Ordinal} (ha : IsSuccLimit a) (h : b < a) : IsSuccLimit (a - b) := by
rw [isSuccLimit_iff, Ordinal.sub_ne_zero_iff_lt, isSuccPrelimit_iff_succ_lt]
refine ⟨h, fun c hc ↦ ?_⟩
rw [lt_sub] at hc ⊢
rw [add_succ]
exact ha.succ_lt hc
@[deprecated (since := "2025-07-09")]
alias isLimit_sub := isSuccLimit_sub
/-! ### Multiplication of ordinals -/ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_sub | null |
monoid : Monoid Ordinal.{u} where
mul a b :=
Quotient.liftOn₂ a b
(fun ⟨α, r, _⟩ ⟨β, s, _⟩ => ⟦⟨β × α, Prod.Lex s r, inferInstance⟩⟧ :
WellOrder → WellOrder → Ordinal)
fun ⟨_, _, _⟩ _ _ _ ⟨f⟩ ⟨g⟩ => Quot.sound ⟨RelIso.prodLexCongr g f⟩
one := 1
mul_assoc a b c :=
Quotient.inductionOn₃ a b c fun ⟨α, r, _⟩ ⟨β, s, _⟩ ⟨γ, t, _⟩ =>
Eq.symm <|
Quotient.sound
⟨⟨prodAssoc _ _ _, @fun a b => by
rcases a with ⟨⟨a₁, a₂⟩, a₃⟩
rcases b with ⟨⟨b₁, b₂⟩, b₃⟩
simp [Prod.lex_def, and_or_left, or_assoc, and_assoc]⟩⟩
mul_one a :=
inductionOn a fun α r _ =>
Quotient.sound
⟨⟨punitProd _, @fun a b => by
rcases a with ⟨⟨⟨⟩⟩, a⟩; rcases b with ⟨⟨⟨⟩⟩, b⟩
simp only [Prod.lex_def, EmptyRelation, false_or]
simp only [true_and]
rfl⟩⟩
one_mul a :=
inductionOn a fun α r _ =>
Quotient.sound
⟨⟨prodPUnit _, @fun a b => by
rcases a with ⟨a, ⟨⟨⟩⟩⟩; rcases b with ⟨b, ⟨⟨⟩⟩⟩
simp only [Prod.lex_def, EmptyRelation, and_false, or_false]
rfl⟩⟩
@[simp] | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | monoid | The multiplication of ordinals `o₁` and `o₂` is the (well-founded) lexicographic order on
`o₂ × o₁`. |
type_prod_lex {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [IsWellOrder α r]
[IsWellOrder β s] : type (Prod.Lex s r) = type r * type s :=
rfl | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | type_prod_lex | null |
private mul_eq_zero' {a b : Ordinal} : a * b = 0 ↔ a = 0 ∨ b = 0 :=
inductionOn a fun α _ _ =>
inductionOn b fun β _ _ => by
simp_rw [← type_prod_lex, type_eq_zero_iff_isEmpty]
rw [or_comm]
exact isEmpty_prod | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_eq_zero' | null |
monoidWithZero : MonoidWithZero Ordinal :=
{ Ordinal.monoid with
zero := 0
mul_zero := fun _a => mul_eq_zero'.2 <| Or.inr rfl
zero_mul := fun _a => mul_eq_zero'.2 <| Or.inl rfl } | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | monoidWithZero | null |
noZeroDivisors : NoZeroDivisors Ordinal :=
⟨fun {_ _} => mul_eq_zero'.1⟩
@[simp] | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | noZeroDivisors | null |
lift_mul (a b : Ordinal.{v}) : lift.{u} (a * b) = lift.{u} a * lift.{u} b :=
Quotient.inductionOn₂ a b fun ⟨_α, _r, _⟩ ⟨_β, _s, _⟩ =>
Quotient.sound
⟨(RelIso.preimage Equiv.ulift _).trans
(RelIso.prodLexCongr (RelIso.preimage Equiv.ulift _)
(RelIso.preimage Equiv.ulift _)).symm⟩
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lift_mul | null |
card_mul (a b) : card (a * b) = card a * card b :=
Quotient.inductionOn₂ a b fun ⟨α, _r, _⟩ ⟨β, _s, _⟩ => mul_comm #β #α | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | card_mul | null |
leftDistribClass : LeftDistribClass Ordinal.{u} :=
⟨fun a b c =>
Quotient.inductionOn₃ a b c fun ⟨α, r, _⟩ ⟨β, s, _⟩ ⟨γ, t, _⟩ =>
Quotient.sound
⟨⟨sumProdDistrib _ _ _, by
rintro ⟨a₁ | a₁, a₂⟩ ⟨b₁ | b₁, b₂⟩ <;>
simp only [Prod.lex_def, Sum.lex_inl_inl, Sum.Lex.sep, Sum.lex_inr_inl, Sum.lex_inr_inr,
sumProdDistrib_apply_left, sumProdDistrib_apply_right, reduceCtorEq] <;>
simp⟩⟩⟩ | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | leftDistribClass | null |
mul_succ (a b : Ordinal) : a * succ b = a * b + a :=
mul_add_one a b | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_succ | null |
mulLeftMono : MulLeftMono Ordinal.{u} :=
⟨fun c a b =>
Quotient.inductionOn₃ a b c fun ⟨α, r, _⟩ ⟨β, s, _⟩ ⟨γ, t, _⟩ ⟨f⟩ => by
refine
(RelEmbedding.ofMonotone (fun a : α × γ => (f a.1, a.2)) fun a b h => ?_).ordinal_type_le
obtain ⟨-, -, h'⟩ | ⟨-, h'⟩ := h
· exact Prod.Lex.left _ _ (f.toRelEmbedding.map_rel_iff.2 h')
· exact Prod.Lex.right _ h'⟩ | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mulLeftMono | null |
mulRightMono : MulRightMono Ordinal.{u} :=
⟨fun c a b =>
Quotient.inductionOn₃ a b c fun ⟨α, r, _⟩ ⟨β, s, _⟩ ⟨γ, t, _⟩ ⟨f⟩ => by
refine
(RelEmbedding.ofMonotone (fun a : γ × α => (a.1, f a.2)) fun a b h => ?_).ordinal_type_le
obtain ⟨-, -, h'⟩ | ⟨-, h'⟩ := h
· exact Prod.Lex.left _ _ h'
· exact Prod.Lex.right _ (f.toRelEmbedding.map_rel_iff.2 h')⟩ | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mulRightMono | null |
le_mul_left (a : Ordinal) {b : Ordinal} (hb : 0 < b) : a ≤ a * b := by
convert mul_le_mul_left' (one_le_iff_pos.2 hb) a
rw [mul_one a] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | le_mul_left | null |
le_mul_right (a : Ordinal) {b : Ordinal} (hb : 0 < b) : a ≤ b * a := by
convert mul_le_mul_right' (one_le_iff_pos.2 hb) a
rw [one_mul a] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | le_mul_right | null |
private mul_le_of_limit_aux {α β r s} [IsWellOrder α r] [IsWellOrder β s] {c}
(h : IsSuccLimit (type s)) (H : ∀ b' < type s, type r * b' ≤ c) (l : c < type r * type s) :
False := by
suffices ∀ a b, Prod.Lex s r (b, a) (enum _ ⟨_, l⟩) by
obtain ⟨b, a⟩ := enum _ ⟨_, l⟩
exact irrefl _ (this _ _)
intro a b
rw [← typein_lt_typein (Prod.Lex s r), typein_enum]
have := H _ (h.succ_lt (typein_lt_type s b))
rw [mul_succ] at this
have := ((add_lt_add_iff_left _).2 (typein_lt_type _ a)).trans_le this
refine (RelEmbedding.ofMonotone (fun a => ?_) fun a b => ?_).ordinal_type_le.trans_lt this
· rcases a with ⟨⟨b', a'⟩, h⟩
by_cases e : b = b'
· refine Sum.inr ⟨a', ?_⟩
subst e
obtain ⟨-, -, h⟩ | ⟨-, h⟩ := h
· exact (irrefl _ h).elim
· exact h
· refine Sum.inl (⟨b', ?_⟩, a')
obtain ⟨-, -, h⟩ | ⟨e, h⟩ := h
· exact h
· exact (e rfl).elim
· rcases a with ⟨⟨b₁, a₁⟩, h₁⟩
rcases b with ⟨⟨b₂, a₂⟩, h₂⟩
intro h
by_cases e₁ : b = b₁ <;> by_cases e₂ : b = b₂
· substs b₁ b₂
simpa only [subrel_val, Prod.lex_def, @irrefl _ s _ b, true_and, false_or,
eq_self_iff_true, dif_pos, Sum.lex_inr_inr] using h
· subst b₁
simp only [subrel_val, Prod.lex_def, e₂, Prod.lex_def, dif_pos, subrel_val,
or_false, dif_neg, not_false_iff, Sum.lex_inr_inl, false_and] at h ⊢
obtain ⟨-, -, h₂_h⟩ | e₂ := h₂ <;> [exact asymm h h₂_h; exact e₂ rfl]
· simp [e₂, show b₂ ≠ b₁ from e₂ ▸ e₁]
· simpa only [dif_neg e₁, dif_neg e₂, Prod.lex_def, subrel_val, Subtype.mk_eq_mk,
Sum.lex_inl_inl] using h | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_le_of_limit_aux | null |
mul_le_iff_of_isSuccLimit {a b c : Ordinal} (h : IsSuccLimit b) :
a * b ≤ c ↔ ∀ b' < b, a * b' ≤ c :=
⟨fun h _ l => (mul_le_mul_left' l.le _).trans h, fun H =>
le_of_not_gt <| by
induction a using inductionOn with
| H α r =>
induction b using inductionOn with
| H β s =>
exact mul_le_of_limit_aux h H⟩
@[deprecated (since := "2025-07-09")]
alias mul_le_of_limit := mul_le_iff_of_isSuccLimit | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_le_iff_of_isSuccLimit | null |
isNormal_mul_right {a : Ordinal} (h : 0 < a) : IsNormal (a * ·) := by
refine IsNormal.of_succ_lt (fun b ↦ ?_) fun hb ↦ ?_
· simpa [mul_succ] using (add_lt_add_iff_left (a * b)).2 h
· simpa [IsLUB, IsLeast, upperBounds, lowerBounds, mul_le_iff_of_isSuccLimit hb] using
fun c hc ↦ mul_le_mul_left' hc.le a | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isNormal_mul_right | null |
lt_mul_iff_of_isSuccLimit {a b c : Ordinal} (h : IsSuccLimit c) :
a < b * c ↔ ∃ c' < c, a < b * c' := by
simpa using (mul_le_iff_of_isSuccLimit h).not
@[deprecated (since := "2025-07-09")]
alias lt_mul_of_limit := lt_mul_iff_of_isSuccLimit | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lt_mul_iff_of_isSuccLimit | null |
@[deprecated mul_lt_mul_iff_right₀ (since := "2025-08-26")]
mul_lt_mul_iff_left {a b c : Ordinal} (a0 : 0 < a) : a * b < a * c ↔ b < c :=
mul_lt_mul_iff_right₀ a0
@[deprecated mul_le_mul_left (since := "2025-08-26")] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_lt_mul_iff_left | null |
mul_le_mul_iff_left {a b c : Ordinal} (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
mul_le_mul_iff_right₀ a0
@[deprecated mul_lt_mul_of_pos_left (since := "2025-08-26")] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_le_mul_iff_left | null |
protected mul_lt_mul_of_pos_left {a b c : Ordinal} (h : a < b) (c0 : 0 < c) : c * a < c * b :=
mul_lt_mul_of_pos_left h c0
@[deprecated mul_pos (since := "2025-08-26")] | lemma | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_lt_mul_of_pos_left | null |
protected mul_pos {a b : Ordinal} (h₁ : 0 < a) (h₂ : 0 < b) : 0 < a * b :=
mul_pos h₁ h₂
@[deprecated mul_ne_zero (since := "2025-08-26")] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_pos | null |
protected mul_ne_zero {a b : Ordinal} (ha : a ≠ 0) (hb : b ≠ 0) : a * b ≠ 0 :=
mul_ne_zero ha hb
@[deprecated mul_le_mul_left (since := "2025-08-26")] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_ne_zero | null |
le_of_mul_le_mul_left {a b c : Ordinal} (h : c * a ≤ c * b) (h0 : 0 < c) : a ≤ b :=
(mul_le_mul_iff_right₀ h0).mp h
@[deprecated mul_left_cancel_iff_of_pos (since := "2025-08-26")] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | le_of_mul_le_mul_left | null |
mul_right_inj {a b c : Ordinal} (a0 : 0 < a) : a * b = a * c ↔ b = c :=
mul_left_cancel_iff_of_pos a0 | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_right_inj | null |
isSuccLimit_mul {a b : Ordinal} (a0 : 0 < a) : IsSuccLimit b → IsSuccLimit (a * b) :=
(isNormal_mul_right a0).isSuccLimit
@[deprecated (since := "2025-07-09")]
alias isLimit_mul := isSuccLimit_mul | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_mul | null |
isSuccLimit_mul_left {a b : Ordinal} (l : IsSuccLimit a) (b0 : 0 < b) :
IsSuccLimit (a * b) := by
rcases zero_or_succ_or_isSuccLimit b with (rfl | ⟨b, rfl⟩ | lb)
· exact b0.false.elim
· rw [mul_succ]
exact isSuccLimit_add _ l
· exact isSuccLimit_mul l.bot_lt lb
@[deprecated (since := "2025-07-09")]
alias isLimit_mul_left := isSuccLimit_mul_left | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | isSuccLimit_mul_left | null |
smul_eq_mul : ∀ (n : ℕ) (a : Ordinal), n • a = a * n
| 0, a => by rw [zero_nsmul, Nat.cast_zero, mul_zero]
| n + 1, a => by rw [succ_nsmul, Nat.cast_add, mul_add, Nat.cast_one, mul_one, smul_eq_mul n] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | smul_eq_mul | null |
private add_mul_limit_aux {a b c : Ordinal} (ba : b + a = a) (l : IsSuccLimit c)
(IH : ∀ c' < c, (a + b) * succ c' = a * succ c' + b) : (a + b) * c = a * c :=
le_antisymm
((mul_le_iff_of_isSuccLimit l).2 fun c' h => by
apply (mul_le_mul_left' (le_succ c') _).trans
rw [IH _ h]
apply (add_le_add_left _ _).trans
· rw [← mul_succ]
exact mul_le_mul_left' (succ_le_of_lt <| l.succ_lt h) _
· rw [← ba]
exact le_add_right _ _)
(mul_le_mul_right' (le_add_right _ _) _) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_mul_limit_aux | null |
add_mul_succ {a b : Ordinal} (c) (ba : b + a = a) : (a + b) * succ c = a * succ c + b := by
induction c using limitRecOn with
| zero => simp only [succ_zero, mul_one]
| succ c IH =>
rw [mul_succ, IH, ← add_assoc, add_assoc _ b, ba, ← mul_succ]
| limit c l IH =>
rw [mul_succ, add_mul_limit_aux ba l IH, mul_succ, add_assoc] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_mul_succ | null |
add_mul_of_isSuccLimit {a b c : Ordinal} (ba : b + a = a) (l : IsSuccLimit c) :
(a + b) * c = a * c :=
add_mul_limit_aux ba l fun c' _ => add_mul_succ c' ba
@[deprecated (since := "2025-07-09")]
alias add_mul_limit := add_mul_of_isSuccLimit
/-! ### Division on ordinals -/ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | add_mul_of_isSuccLimit | null |
private div_nonempty {a b : Ordinal} (h : b ≠ 0) : { o | a < b * succ o }.Nonempty :=
⟨a, (succ_le_iff (a := a) (b := b * succ a)).1 <| by
simpa only [succ_zero, one_mul] using
mul_le_mul_right' (succ_le_of_lt (Ordinal.pos_iff_ne_zero.2 h)) (succ a)⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_nonempty | The set in the definition of division is nonempty. |
div : Div Ordinal :=
⟨fun a b => if b = 0 then 0 else sInf { o | a < b * succ o }⟩
@[simp] | instance | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div | `a / b` is the unique ordinal `o` satisfying `a = b * o + o'` with `o' < b`. |
div_zero (a : Ordinal) : a / 0 = 0 :=
dif_pos rfl | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_zero | null |
private div_def (a) {b : Ordinal} (h : b ≠ 0) : a / b = sInf { o | a < b * succ o } :=
dif_neg h | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_def | null |
lt_mul_succ_div (a) {b : Ordinal} (h : b ≠ 0) : a < b * succ (a / b) := by
rw [div_def a h]; exact csInf_mem (div_nonempty h) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lt_mul_succ_div | null |
lt_mul_div_add (a) {b : Ordinal} (h : b ≠ 0) : a < b * (a / b) + b := by
simpa only [mul_succ] using lt_mul_succ_div a h | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lt_mul_div_add | null |
div_le {a b c : Ordinal} (b0 : b ≠ 0) : a / b ≤ c ↔ a < b * succ c :=
⟨fun h => (lt_mul_succ_div a b0).trans_le (mul_le_mul_left' (succ_le_succ_iff.2 h) _), fun h => by
rw [div_def a b0]; exact csInf_le' h⟩ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_le | null |
lt_div {a b c : Ordinal} (h : c ≠ 0) : a < b / c ↔ c * succ a ≤ b := by
rw [← not_le, div_le h, not_lt] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | lt_div | null |
div_pos {b c : Ordinal} (h : c ≠ 0) : 0 < b / c ↔ c ≤ b := by simp [lt_div h] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_pos | null |
le_div {a b c : Ordinal} (c0 : c ≠ 0) : a ≤ b / c ↔ c * a ≤ b := by
induction a using limitRecOn with
| zero => simp only [mul_zero, Ordinal.zero_le]
| succ _ _ => rw [succ_le_iff, lt_div c0]
| limit _ h₁ h₂ =>
revert h₁ h₂
simp +contextual only [mul_le_iff_of_isSuccLimit, IsSuccLimit.le_iff_forall_le, forall_true_iff] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | le_div | null |
div_lt {a b c : Ordinal} (b0 : b ≠ 0) : a / b < c ↔ a < b * c :=
lt_iff_lt_of_le_iff_le <| le_div b0 | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_lt | null |
div_le_of_le_mul {a b c : Ordinal} (h : a ≤ b * c) : a / b ≤ c :=
if b0 : b = 0 then by simp only [b0, div_zero, Ordinal.zero_le]
else
(div_le b0).2 <| h.trans_lt <| mul_lt_mul_of_pos_left (lt_succ c) (Ordinal.pos_iff_ne_zero.2 b0) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_le_of_le_mul | null |
mul_lt_of_lt_div {a b c : Ordinal} : a < b / c → c * a < b :=
lt_imp_lt_of_le_imp_le div_le_of_le_mul
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_lt_of_lt_div | null |
zero_div (a : Ordinal) : 0 / a = 0 :=
Ordinal.le_zero.1 <| div_le_of_le_mul <| Ordinal.zero_le _ | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | zero_div | null |
mul_div_le (a b : Ordinal) : b * (a / b) ≤ a :=
if b0 : b = 0 then by simp only [b0, zero_mul, Ordinal.zero_le] else (le_div b0).1 le_rfl | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_div_le | null |
div_le_left {a b : Ordinal} (h : a ≤ b) (c : Ordinal) : a / c ≤ b / c := by
obtain rfl | hc := eq_or_ne c 0
· rw [div_zero, div_zero]
· rw [le_div hc]
exact (mul_div_le a c).trans h | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_le_left | null |
mul_add_div (a) {b : Ordinal} (b0 : b ≠ 0) (c) : (b * a + c) / b = a + c / b := by
apply le_antisymm
· apply (div_le b0).2
rw [mul_succ, mul_add, add_assoc, add_lt_add_iff_left]
apply lt_mul_div_add _ b0
· rw [le_div b0, mul_add, add_le_add_iff_left]
apply mul_div_le | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_add_div | null |
div_eq_zero_of_lt {a b : Ordinal} (h : a < b) : a / b = 0 := by
rw [← Ordinal.le_zero, div_le <| Ordinal.pos_iff_ne_zero.1 <| (Ordinal.zero_le _).trans_lt h]
simpa only [succ_zero, mul_one] using h
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_eq_zero_of_lt | null |
mul_div_cancel (a) {b : Ordinal} (b0 : b ≠ 0) : b * a / b = a := by
simpa only [add_zero, zero_div] using mul_add_div a b0 0 | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_div_cancel | null |
mul_add_div_mul {a c : Ordinal} (hc : c < a) (b d : Ordinal) :
(a * b + c) / (a * d) = b / d := by
have ha : a ≠ 0 := ((Ordinal.zero_le c).trans_lt hc).ne'
obtain rfl | hd := eq_or_ne d 0
· rw [mul_zero, div_zero, div_zero]
· have H := mul_ne_zero ha hd
apply le_antisymm
· rw [← lt_succ_iff, div_lt H, mul_assoc]
· apply (add_lt_add_left hc _).trans_le
rw [← mul_succ]
apply mul_le_mul_left'
rw [succ_le_iff]
exact lt_mul_succ_div b hd
· rw [le_div H, mul_assoc]
exact (mul_le_mul_left' (mul_div_le b d) a).trans (le_add_right _ c) | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_add_div_mul | null |
mul_div_mul_cancel {a : Ordinal} (ha : a ≠ 0) (b c) : a * b / (a * c) = b / c := by
convert mul_add_div_mul (Ordinal.pos_iff_ne_zero.2 ha) b c using 1
rw [add_zero]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | mul_div_mul_cancel | null |
div_one (a : Ordinal) : a / 1 = a := by
simpa only [one_mul] using mul_div_cancel a Ordinal.one_ne_zero
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.GroupWithZero.Divisibility",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.SuccPred.InitialSeg",
"Mathlib.SetTheory.Ordinal.Basic"
] | Mathlib/SetTheory/Ordinal/Arithmetic.lean | div_one | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.