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 ⌀ |
|---|---|---|---|---|---|---|
veblen_zero_apply (a : Ordinal) : veblen 0 a = ω ^ a := by
rw [veblen_zero] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_zero_apply | null |
veblen_of_ne_zero (h : o ≠ 0) : veblen o = derivFamily fun x : Iio o ↦ veblen x.1 :=
veblenWith_of_ne_zero _ h | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_of_ne_zero | null |
isNormal_veblen (o : Ordinal) : IsNormal (veblen o) :=
(isNormal_opow one_lt_omega0).veblenWith o | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | isNormal_veblen | null |
mem_range_veblen (h : o ≠ 0) : a ∈ range (veblen o) ↔ ∀ b < o, veblen b a = a :=
mem_range_veblenWith (isNormal_opow one_lt_omega0) h | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | mem_range_veblen | null |
veblen_veblen_of_lt (h : o₁ < o₂) (a : Ordinal) : veblen o₁ (veblen o₂ a) = veblen o₂ a :=
veblenWith_veblenWith_of_lt (isNormal_opow one_lt_omega0) h a | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_veblen_of_lt | null |
veblen_eq_self_of_le (h : o₁ ≤ o₂) (h' : veblen o₂ a = a) : veblen o₁ a = a :=
veblenWith_eq_self_of_le (isNormal_opow one_lt_omega0) h h' | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_eq_self_of_le | null |
veblen_mem_range_opow (o a : Ordinal) : veblen o a ∈ range (ω ^ · : Ordinal → Ordinal) :=
veblenWith_mem_range (isNormal_opow one_lt_omega0) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_mem_range_opow | null |
veblen_succ (o : Ordinal) : veblen (succ o) = deriv (veblen o) :=
veblenWith_succ (isNormal_opow one_lt_omega0) o | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_succ | null |
veblen_right_strictMono (o : Ordinal) : StrictMono (veblen o) :=
veblenWith_right_strictMono (isNormal_opow one_lt_omega0) o
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_right_strictMono | null |
veblen_lt_veblen_iff_right : veblen o a < veblen o b ↔ a < b :=
veblenWith_lt_veblenWith_iff_right (isNormal_opow one_lt_omega0)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_lt_veblen_iff_right | null |
veblen_le_veblen_iff_right : veblen o a ≤ veblen o b ↔ a ≤ b :=
veblenWith_le_veblenWith_iff_right (isNormal_opow one_lt_omega0) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_le_veblen_iff_right | null |
veblen_injective (o : Ordinal) : Function.Injective (veblen o) :=
veblenWith_injective (isNormal_opow one_lt_omega0) o
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_injective | null |
veblen_inj : veblen o a = veblen o b ↔ a = b :=
(veblen_injective o).eq_iff | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_inj | null |
right_le_veblen (o a : Ordinal) : a ≤ veblen o a :=
right_le_veblenWith (isNormal_opow one_lt_omega0) o a | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | right_le_veblen | null |
veblen_left_monotone (o : Ordinal) : Monotone (veblen · o) :=
veblenWith_left_monotone (isNormal_opow one_lt_omega0) o
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_left_monotone | null |
veblen_pos : 0 < veblen o a :=
veblenWith_pos (isNormal_opow one_lt_omega0) (by simp) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_pos | null |
veblen_zero_strictMono : StrictMono (veblen · 0) :=
veblenWith_zero_strictMono (isNormal_opow one_lt_omega0) (by simp)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_zero_strictMono | null |
veblen_zero_lt_veblen_zero : veblen o₁ 0 < veblen o₂ 0 ↔ o₁ < o₂ :=
veblen_zero_strictMono.lt_iff_lt
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_zero_lt_veblen_zero | null |
veblen_zero_le_veblen_zero : veblen o₁ 0 ≤ veblen o₂ 0 ↔ o₁ ≤ o₂ :=
veblen_zero_strictMono.le_iff_le
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_zero_le_veblen_zero | null |
veblen_zero_inj : veblen o₁ 0 = veblen o₂ 0 ↔ o₁ = o₂ :=
veblen_zero_strictMono.injective.eq_iff | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_zero_inj | null |
left_le_veblen (o a : Ordinal) : o ≤ veblen o a :=
left_le_veblenWith (isNormal_opow one_lt_omega0) (by simp) o a | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | left_le_veblen | null |
isNormal_veblen_zero : IsNormal (veblen · 0) :=
(isNormal_opow one_lt_omega0).veblenWith_zero (by simp) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | isNormal_veblen_zero | null |
veblen_veblen_eq_veblen_iff (h : o₂ ≤ o₁) :
veblen o₁ (veblen o₂ a) = veblen o₂ a ↔ veblen o₁ a = a :=
veblenWith_veblenWith_eq_veblenWith_iff (isNormal_opow one_lt_omega0) h | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_veblen_eq_veblen_iff | null |
veblen_lt_veblen_veblen_iff (h : o₂ ≤ o₁) :
veblen o₂ a < veblen o₁ (veblen o₂ a) ↔ a < veblen o₁ a :=
veblenWith_lt_veblenWith_veblenWith_iff (isNormal_opow one_lt_omega0) h | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_lt_veblen_veblen_iff | null |
veblen_opow_eq_opow_iff : veblen o (ω ^ a) = ω ^ a ↔ veblen o a = a :=
veblenWith_apply_eq_apply_iff (isNormal_opow one_lt_omega0) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_opow_eq_opow_iff | null |
opow_lt_veblen_opow_iff : ω ^ a < veblen o (ω ^ a) ↔ a < veblen o a :=
apply_lt_veblenWith_apply_iff (isNormal_opow one_lt_omega0) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | opow_lt_veblen_opow_iff | null |
lt_veblen (a : Ordinal) : a < veblen a a := by
obtain rfl | h := eq_zero_or_pos a
· simp
· apply (left_le_veblen a 0).trans_lt
simpa | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | lt_veblen | null |
cmp_veblen : cmp (veblen o₁ a) (veblen o₂ b) =
match cmp o₁ o₂ with
| .eq => cmp a b
| .lt => cmp a (veblen o₂ b)
| .gt => cmp (veblen o₁ a) b :=
cmp_veblenWith (isNormal_opow one_lt_omega0) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | cmp_veblen | null |
veblen_lt_veblen_iff :
veblen o₁ a < veblen o₂ b ↔
o₁ = o₂ ∧ a < b ∨ o₁ < o₂ ∧ a < veblen o₂ b ∨ o₂ < o₁ ∧ veblen o₁ a < b :=
veblenWith_lt_veblenWith_iff (isNormal_opow one_lt_omega0) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_lt_veblen_iff | `veblen o₁ a < veblen o₂ b` iff one of the following holds:
* `o₁ = o₂` and `a < b`
* `o₁ < o₂` and `a < veblen o₂ b`
* `o₁ > o₂` and `veblen o₁ a < b` |
veblen_le_veblen_iff :
veblen o₁ a ≤ veblen o₂ b ↔
o₁ = o₂ ∧ a ≤ b ∨ o₁ < o₂ ∧ a ≤ veblen o₂ b ∨ o₂ < o₁ ∧ veblen o₁ a ≤ b :=
veblenWith_le_veblenWith_iff (isNormal_opow one_lt_omega0) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_le_veblen_iff | `veblen o₁ a ≤ veblen o₂ b` iff one of the following holds:
* `o₁ = o₂` and `a ≤ b`
* `o₁ < o₂` and `a ≤ veblen o₂ b`
* `o₁ > o₂` and `veblen o₁ a ≤ b` |
veblen_eq_veblen_iff :
veblen o₁ a = veblen o₂ b ↔
o₁ = o₂ ∧ a = b ∨ o₁ < o₂ ∧ a = veblen o₂ b ∨ o₂ < o₁ ∧ veblen o₁ a = b :=
veblenWith_eq_veblenWith_iff (isNormal_opow one_lt_omega0) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_eq_veblen_iff | `veblen o₁ a ≤ veblen o₂ b` iff one of the following holds:
* `o₁ = o₂` and `a = b`
* `o₁ < o₂` and `a = veblen o₂ b`
* `o₁ > o₂` and `veblen o₁ a = b` |
invVeblen₁ (x : Ordinal) : Ordinal :=
sInf {y | veblen y x ≠ x} | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁ | For any given `x`, there exists a unique pair `(o, a)` such that `ω ^ x = veblen o a` and
`a < ω ^ x`. `invVeblen₁ x` and `invVeblen₂ x` return the first and second entries of this pair,
respectively. See `veblen_eq_opow_iff` for a proof.
Composing this function with `Ordinal.CNF` yields a predicative ordinal notation up to `Γ₀`. |
veblen_eq_of_lt_invVeblen₁ (h : o < invVeblen₁ x) : veblen o x = x := by
simpa using notMem_of_lt_csInf' h | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_eq_of_lt_invVeblen₁ | null |
invVeblen₁_le (x : Ordinal) : invVeblen₁ x ≤ x :=
csInf_le' (lt_veblen x).ne' | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁_le | null |
lt_veblen_invVeblen₁ (x : Ordinal) : x < veblen (invVeblen₁ x) x :=
(right_le_veblen ..).lt_of_ne' (csInf_mem (s := {y | veblen y x ≠ x}) ⟨x, (lt_veblen x).ne'⟩) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | lt_veblen_invVeblen₁ | null |
lt_veblen_iff_invVeblen₁_le : a < veblen o a ↔ invVeblen₁ a ≤ o := by
obtain h | h := lt_or_ge o (invVeblen₁ a)
· rw [veblen_eq_of_lt_invVeblen₁ h]
simpa
· simpa [(lt_veblen_invVeblen₁ a).trans_le (veblen_left_monotone _ h)] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | lt_veblen_iff_invVeblen₁_le | null |
mem_range_veblen_iff_le_invVeblen₁ : ω ^ x ∈ range (veblen o) ↔ o ≤ invVeblen₁ x := by
obtain h | rfl | h := lt_trichotomy o (invVeblen₁ x)
· exact iff_of_true ⟨_, veblen_opow_eq_opow_iff.2 <| veblen_eq_of_lt_invVeblen₁ h⟩ h.le
· apply iff_of_true _ le_rfl
by_cases h : invVeblen₁ x = 0
· simp [h]
· simp_rw [mem_range_veblen h, veblen_opow_eq_opow_iff]
exact fun o ↦ veblen_eq_of_lt_invVeblen₁
· apply iff_of_false _ h.not_ge
rintro ⟨z, hz⟩
have hz' := hz
rw [← veblen_veblen_of_lt h, hz', veblen_opow_eq_opow_iff] at hz
exact (lt_veblen_invVeblen₁ x).ne' hz | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | mem_range_veblen_iff_le_invVeblen₁ | null |
invVeblen₁_veblen (h : a < veblen o a) : invVeblen₁ (veblen o a) = o := by
apply le_antisymm
· rwa [← lt_veblen_iff_invVeblen₁_le, veblen_lt_veblen_iff_right]
· rw [← mem_range_veblen_iff_le_invVeblen₁]
obtain rfl | ho := eq_zero_or_pos o
· simp
· rw [← veblen_zero_apply, veblen_veblen_of_lt ho]
simp | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁_veblen | null |
invVeblen₁_of_lt_opow (h : a < ω ^ a) : invVeblen₁ a = 0 := by
rwa [← Ordinal.le_zero, ← lt_veblen_iff_invVeblen₁_le, veblen_zero]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁_of_lt_opow | null |
invVeblen₁_zero : invVeblen₁ 0 = 0 :=
invVeblen₁_of_lt_opow <| by simp
@[inherit_doc invVeblen₁] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁_zero | null |
invVeblen₂ (x : Ordinal) : Ordinal :=
Classical.choose ((mem_range_veblen_iff_le_invVeblen₁ (x := x)).2 le_rfl)
@[simp] | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂ | null |
veblen_invVeblen₁_invVeblen₂ (x : Ordinal) : veblen (invVeblen₁ x) (invVeblen₂ x) = ω ^ x :=
Classical.choose_spec (mem_range_veblen_iff_le_invVeblen₁.2 le_rfl) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_invVeblen₁_invVeblen₂ | null |
invVeblen₂_eq_iff : invVeblen₂ x = a ↔ ω ^ x = veblen (invVeblen₁ x) a := by
rw [← veblen_inj (o := x.invVeblen₁), veblen_invVeblen₁_invVeblen₂] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_eq_iff | null |
invVeblen₂_lt_iff : invVeblen₂ x < a ↔ ω ^ x < veblen (invVeblen₁ x) a := by
rw [← veblen_lt_veblen_iff_right (o := x.invVeblen₁), veblen_invVeblen₁_invVeblen₂] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_lt_iff | null |
invVeblen₂_le_iff : invVeblen₂ x ≤ a ↔ ω ^ x ≤ veblen (invVeblen₁ x) a := by
rw [← veblen_le_veblen_iff_right (o := x.invVeblen₁), veblen_invVeblen₁_invVeblen₂] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_le_iff | null |
lt_invVeblen₂_iff : a < invVeblen₂ x ↔ veblen (invVeblen₁ x) a < ω ^ x := by
rw [← veblen_lt_veblen_iff_right (o := x.invVeblen₁), veblen_invVeblen₁_invVeblen₂] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | lt_invVeblen₂_iff | null |
le_invVeblen₂_iff : a ≤ invVeblen₂ x ↔ veblen (invVeblen₁ x) a ≤ ω ^ x := by
rw [← veblen_le_veblen_iff_right (o := x.invVeblen₁), veblen_invVeblen₁_invVeblen₂] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | le_invVeblen₂_iff | null |
invVeblen₂_lt (x : Ordinal) : invVeblen₂ x < ω ^ x := by
rw [invVeblen₂_lt_iff, opow_lt_veblen_opow_iff]
exact lt_veblen_invVeblen₁ x | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_lt | null |
invVeblen₂_le (x : Ordinal) : invVeblen₂ x ≤ x := by
obtain h | h := eq_zero_or_pos (invVeblen₁ x)
· rw [invVeblen₂_le_iff, h, veblen_zero]
· convert (invVeblen₂_lt x).le
rw [← veblen_zero_apply, veblen_eq_of_lt_invVeblen₁ h] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_le | null |
invVeblen₂_of_lt_opow (h : a < ω ^ a) : invVeblen₂ a = a := by
rw [invVeblen₂_eq_iff, invVeblen₁_of_lt_opow h, veblen_zero_apply]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_of_lt_opow | null |
invVeblen₂_zero : invVeblen₂ 0 = 0 := by
apply invVeblen₂_of_lt_opow
simp | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_zero | null |
invVeblen₂_veblen (ho : o ≠ 0) (h : a < veblen o a) : invVeblen₂ (veblen o a) = a := by
rw [invVeblen₂_eq_iff, invVeblen₁_veblen h, ← veblen_zero_apply, veblen_veblen_of_lt]
exact ho.bot_lt | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_veblen | null |
veblen_eq_opow_iff (h : a < veblen o a) :
veblen o a = ω ^ x ↔ invVeblen₁ x = o ∧ invVeblen₂ x = a := by
refine ⟨?_, fun ⟨hx, ha⟩ ↦ ?_⟩
· obtain rfl | ho := eq_zero_or_pos o
· rw [veblen_zero] at h
have := invVeblen₁_of_lt_opow h
have := invVeblen₂_of_lt_opow h
aesop
· rw [← veblen_veblen_of_lt ho, veblen_zero_apply, opow_right_inj one_lt_omega0]
rintro rfl
simp [invVeblen₁_veblen h, invVeblen₂_veblen ho.ne' h]
· convert ← veblen_invVeblen₁_invVeblen₂ x
/-! ### Epsilon function -/ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | veblen_eq_opow_iff | null |
epsilon := veblen 1
@[inherit_doc] scoped notation "ε_ " => epsilon | abbrev | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | epsilon | The epsilon function enumerates the fixed points of `ω ^ ⬝`.
This is an abbreviation for `veblen 1`. |
lt_epsilon0 : o < ε₀ ↔ ∃ n : ℕ, o < (fun a ↦ ω ^ a)^[n] 0 := by
rw [epsilon0_eq_nfp, lt_nfp_iff] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | lt_epsilon0 | `ε₀` is the first fixed point of `ω ^ ⬝`, i.e. the supremum of `ω`, `ω ^ ω`, `ω ^ ω ^ ω`, … -/
scoped notation "ε₀" => ε_ 0
theorem epsilon_eq_deriv (o : Ordinal) : ε_ o = deriv (fun a ↦ ω ^ a) o := by
rw [epsilon, ← succ_zero, veblen_succ, veblen_zero]
theorem epsilon0_eq_nfp : ε₀ = nfp (fun a ↦ ω ^ a) 0 := by
rw [epsilon_eq_deriv, deriv_zero_right]
theorem epsilon_succ_eq_nfp (o : Ordinal) : ε_ (succ o) = nfp (fun a ↦ ω ^ a) (succ (ε_ o)) := by
rw [epsilon_eq_deriv, epsilon_eq_deriv, deriv_succ]
theorem epsilon0_le_of_omega0_opow_le (h : ω ^ o ≤ o) : ε₀ ≤ o := by
rw [epsilon0_eq_nfp]
exact nfp_le_fp (fun _ _ ↦ (opow_le_opow_iff_right one_lt_omega0).2) (Ordinal.zero_le o) h
@[simp]
theorem omega0_opow_epsilon (o : Ordinal) : ω ^ ε_ o = ε_ o := by
rw [epsilon_eq_deriv, (isNormal_opow one_lt_omega0).deriv_fp]
/-- `ε₀` is the limit of `0`, `ω ^ 0`, `ω ^ ω ^ 0`, … |
iterate_omega0_opow_lt_epsilon0 (n : ℕ) : (fun a ↦ ω ^ a)^[n] 0 < ε₀ := by
rw [epsilon0_eq_nfp]
apply iterate_lt_nfp (isNormal_opow one_lt_omega0).strictMono
simp | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | iterate_omega0_opow_lt_epsilon0 | `ω ^ ω ^ … ^ 0 < ε₀` |
omega0_lt_epsilon (o : Ordinal) : ω < ε_ o := by
apply lt_of_lt_of_le _ <| (veblen_right_strictMono _).monotone (Ordinal.zero_le o)
simpa using iterate_omega0_opow_lt_epsilon0 2 | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | omega0_lt_epsilon | null |
natCast_lt_epsilon (n : ℕ) (o : Ordinal) : n < ε_ o :=
(nat_lt_omega0 n).trans <| omega0_lt_epsilon o | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | natCast_lt_epsilon | null |
epsilon_pos (o : Ordinal) : 0 < ε_ o :=
veblen_pos | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | epsilon_pos | null |
invVeblen₁_epsilon (h : o < ε_ o) : invVeblen₁ (ε_ o) = 1 :=
invVeblen₁_veblen h | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁_epsilon | null |
invVeblen₂_epsilon (h : o < ε_ o) : invVeblen₂ (ε_ o) = o :=
invVeblen₂_veblen one_ne_zero h
/-! ### Gamma function -/ | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_epsilon | null |
gamma : Ordinal → Ordinal :=
deriv (veblen · 0)
@[inherit_doc]
scoped notation "Γ_ " => gamma | def | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | gamma | The gamma function enumerates the fixed points of `veblen · 0`.
Of particular importance is `Γ₀ = gamma 0`, the Feferman-Schütte ordinal. |
lt_gamma0 : o < Γ₀ ↔ ∃ n : ℕ, o < (fun a ↦ veblen a 0)^[n] 0 := by
rw [gamma0_eq_nfp, lt_nfp_iff] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | lt_gamma0 | The Feferman-Schütte ordinal `Γ₀` is the smallest fixed point of `veblen · 0`, i.e. the supremum
of `veblen ε₀ 0`, `veblen (veblen ε₀ 0) 0`, etc. -/
scoped notation "Γ₀" => Γ_ 0
theorem isNormal_gamma : IsNormal gamma :=
isNormal_deriv _
theorem mem_range_gamma : o ∈ range Γ_ ↔ veblen o 0 = o :=
isNormal_veblen_zero.mem_range_deriv
theorem strictMono_gamma : StrictMono gamma :=
isNormal_gamma.strictMono
theorem monotone_gamma : Monotone gamma :=
isNormal_gamma.monotone
@[simp]
theorem gamma_lt_gamma : Γ_ a < Γ_ b ↔ a < b :=
strictMono_gamma.lt_iff_lt
@[simp]
theorem gamma_le_gamma : Γ_ a ≤ Γ_ b ↔ a ≤ b :=
strictMono_gamma.le_iff_le
@[simp]
theorem gamma_inj : Γ_ a = Γ_ b ↔ a = b :=
strictMono_gamma.injective.eq_iff
@[simp]
theorem veblen_gamma_zero (o : Ordinal) : veblen (Γ_ o) 0 = Γ_ o :=
isNormal_veblen_zero.deriv_fp o
theorem gamma0_eq_nfp : Γ₀ = nfp (veblen · 0) 0 :=
deriv_zero_right _
theorem gamma_succ_eq_nfp (o : Ordinal) : Γ_ (succ o) = nfp (veblen · 0) (succ (Γ_ o)) :=
deriv_succ _ _
theorem gamma0_le_of_veblen_le (h : veblen o 0 ≤ o) : Γ₀ ≤ o := by
rw [gamma0_eq_nfp]
exact nfp_le_fp (veblen_left_monotone 0) (Ordinal.zero_le o) h
/-- `Γ₀` is the limit of `0`, `veblen 0 0`, `veblen (veblen 0 0) 0`, … |
iterate_veblen_lt_gamma0 (n : ℕ) : (fun a ↦ veblen a 0)^[n] 0 < Γ₀ := by
rw [gamma0_eq_nfp]
apply iterate_lt_nfp veblen_zero_strictMono
simp | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | iterate_veblen_lt_gamma0 | `veblen (veblen … (veblen 0 0) … 0) 0 < Γ₀` |
epsilon0_lt_gamma (o : Ordinal) : ε₀ < Γ_ o := by
apply lt_of_lt_of_le _ <| (gamma_le_gamma.2 (Ordinal.zero_le _))
simpa using iterate_veblen_lt_gamma0 2 | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | epsilon0_lt_gamma | null |
omega0_lt_gamma (o : Ordinal) : ω < Γ_ o :=
(omega0_lt_epsilon 0).trans (epsilon0_lt_gamma o) | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | omega0_lt_gamma | null |
natCast_lt_gamma (n : ℕ) : n < Γ_ o :=
(nat_lt_omega0 n).trans (omega0_lt_gamma o)
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | natCast_lt_gamma | null |
gamma_pos : 0 < Γ_ o :=
natCast_lt_gamma 0
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | gamma_pos | null |
gamma_ne_zero : Γ_ o ≠ 0 :=
gamma_pos.ne'
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | gamma_ne_zero | null |
invVeblen₁_gamma (o : Ordinal) : invVeblen₁ (Γ_ o) = Γ_ o := by
rw [← veblen_gamma_zero, invVeblen₁_veblen veblen_pos, veblen_gamma_zero]
@[simp] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁_gamma | null |
invVeblen₂_gamma (o : Ordinal) : invVeblen₂ (Γ_ o) = 0 := by
rw [← veblen_gamma_zero, invVeblen₂_veblen gamma_ne_zero veblen_pos] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₂_gamma | null |
invVeblen₁_eq_iff : invVeblen₁ o = o ↔ o = 0 ∨ o ∈ range Γ_ := by
constructor
· rw [mem_range_gamma, or_iff_not_imp_left]
refine fun h ho ↦ (left_le_veblen ..).antisymm' ?_
conv_rhs => rw [← veblen_eq_of_lt_invVeblen₁ (h.trans_ne ho).bot_lt, bot_eq_zero,
veblen_zero_apply, ← veblen_invVeblen₁_invVeblen₂, h]
simp
· aesop | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁_eq_iff | null |
invVeblen₁_lt_iff : invVeblen₁ o < o ↔ o ≠ 0 ∧ o ∉ range Γ_ := by
rw [(invVeblen₁_le o).lt_iff_ne, ne_eq, invVeblen₁_eq_iff, not_or] | theorem | SetTheory | [
"Mathlib.SetTheory.Ordinal.FixedPoint"
] | Mathlib/SetTheory/Ordinal/Veblen.lean | invVeblen₁_lt_iff | null |
le_iff_sub_nonneg {x y : PGame} : x ≤ y ↔ 0 ≤ y - x := sorry | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | le_iff_sub_nonneg | null |
lt_iff_sub_pos {x y : PGame} : x < y ↔ 0 < y - x := sorry
```
We show that these operations respect the equivalence relation, and hence descend to games. At the
level of games, these operations satisfy all the laws of a commutative group. To prove the necessary
equivalence relations at the level of pregames, the notion of a `Relabelling` of a game is used
(defined in `Mathlib/SetTheory/PGame/Basic.lean`); for example, there is a relabelling between
`x + (y + z)` and `(x + y) + z`.
-/ | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | lt_iff_sub_pos | null |
neg : PGame → PGame
| ⟨l, r, L, R⟩ => ⟨r, l, fun i => neg (R i), fun i => neg (L i)⟩ | def | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | neg | The negation of `{L | R}` is `{-R | -L}`. |
@[simp]
neg_def {xl xr xL xR} : -mk xl xr xL xR = mk xr xl (-xR ·) (-xL ·) :=
rfl | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | neg_def | null |
@[simp]
neg_ofLists (L R : List PGame) :
-ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
simp only [ofLists, neg_def, List.getElem_map, mk.injEq, List.length_map, true_and]
constructor
all_goals
apply hfunext
· simp
· rintro ⟨⟨a, ha⟩⟩ ⟨⟨b, hb⟩⟩ h
have :
∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : b ≍ c),
(b.down : ℕ) = ↑c.down := by
rintro m n rfl b c
simp only [heq_eq_eq]
rintro rfl
rfl
simp only [heq_eq_eq]
congr 5
exact this (List.length_map _).symm h | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | neg_ofLists | null |
isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
rw [isOption_iff, isOption_iff, or_comm]
cases y
apply or_congr <;>
· apply exists_congr
intro
rw [neg_eq_iff_eq_neg]
simp only [neg_def, moveRight_mk, moveLeft_mk]
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | isOption_neg | null |
isOption_neg_neg {x y : PGame} : IsOption (-x) (-y) ↔ IsOption x y := by
rw [isOption_neg, neg_neg] | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | isOption_neg_neg | null |
leftMoves_neg : ∀ x : PGame, (-x).LeftMoves = x.RightMoves
| ⟨_, _, _, _⟩ => rfl | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | leftMoves_neg | Use `toLeftMovesNeg` to cast between these two types. |
rightMoves_neg : ∀ x : PGame, (-x).RightMoves = x.LeftMoves
| ⟨_, _, _, _⟩ => rfl | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | rightMoves_neg | Use `toRightMovesNeg` to cast between these two types. |
toLeftMovesNeg {x : PGame} : x.RightMoves ≃ (-x).LeftMoves :=
Equiv.cast (leftMoves_neg x).symm | def | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | toLeftMovesNeg | Turns a right move for `x` into a left move for `-x` and vice versa.
Even though these types are the same (not definitionally so), this is the preferred way to convert
between them. |
toRightMovesNeg {x : PGame} : x.LeftMoves ≃ (-x).RightMoves :=
Equiv.cast (rightMoves_neg x).symm
@[simp] | def | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | toRightMovesNeg | Turns a left move for `x` into a right move for `-x` and vice versa.
Even though these types are the same (not definitionally so), this is the preferred way to convert
between them. |
moveLeft_neg {x : PGame} (i) :
(-x).moveLeft i = -x.moveRight (toLeftMovesNeg.symm i) := by
cases x
rfl | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | moveLeft_neg | null |
moveLeft_neg_toLeftMovesNeg {x : PGame} (i) :
(-x).moveLeft (toLeftMovesNeg i) = -x.moveRight i := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | moveLeft_neg_toLeftMovesNeg | null |
moveRight_neg {x : PGame} (i) :
(-x).moveRight i = -x.moveLeft (toRightMovesNeg.symm i) := by
cases x
rfl | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | moveRight_neg | null |
moveRight_neg_toRightMovesNeg {x : PGame} (i) :
(-x).moveRight (toRightMovesNeg i) = -x.moveLeft i := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | moveRight_neg_toRightMovesNeg | null |
forall_leftMoves_neg {x : PGame} {p : (-x).LeftMoves → Prop} :
(∀ i : (-x).LeftMoves, p i) ↔ (∀ i : x.RightMoves, p (toLeftMovesNeg i)) :=
toLeftMovesNeg.forall_congr_right.symm
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | forall_leftMoves_neg | null |
exists_leftMoves_neg {x : PGame} {p : (-x).LeftMoves → Prop} :
(∃ i : (-x).LeftMoves, p i) ↔ (∃ i : x.RightMoves, p (toLeftMovesNeg i)) :=
toLeftMovesNeg.exists_congr_right.symm
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | exists_leftMoves_neg | null |
forall_rightMoves_neg {x : PGame} {p : (-x).RightMoves → Prop} :
(∀ i : (-x).RightMoves, p i) ↔ (∀ i : x.LeftMoves, p (toRightMovesNeg i)) :=
toRightMovesNeg.forall_congr_right.symm
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | forall_rightMoves_neg | null |
exists_rightMoves_neg {x : PGame} {p : (-x).RightMoves → Prop} :
(∃ i : (-x).RightMoves, p i) ↔ (∃ i : x.LeftMoves, p (toRightMovesNeg i)) :=
toRightMovesNeg.exists_congr_right.symm | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | exists_rightMoves_neg | null |
leftMoves_neg_cases {x : PGame} (k) {P : (-x).LeftMoves → Prop}
(h : ∀ i, P <| toLeftMovesNeg i) :
P k := by
rw [← toLeftMovesNeg.apply_symm_apply k]
exact h _ | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | leftMoves_neg_cases | null |
rightMoves_neg_cases {x : PGame} (k) {P : (-x).RightMoves → Prop}
(h : ∀ i, P <| toRightMovesNeg i) :
P k := by
rw [← toRightMovesNeg.apply_symm_apply k]
exact h _ | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | rightMoves_neg_cases | null |
Identical.neg : ∀ {x₁ x₂ : PGame}, x₁ ≡ x₂ → -x₁ ≡ -x₂
| mk _ _ _ _, mk _ _ _ _, ⟨⟨hL₁, hL₂⟩, ⟨hR₁, hR₂⟩⟩ =>
⟨⟨fun i ↦ (hR₁ i).imp (fun _ ↦ Identical.neg), fun j ↦ (hR₂ j).imp (fun _ ↦ Identical.neg)⟩,
⟨fun i ↦ (hL₁ i).imp (fun _ ↦ Identical.neg), fun j ↦ (hL₂ j).imp (fun _ ↦ Identical.neg)⟩⟩ | lemma | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | Identical.neg | If `x` has the same moves as `y`, then `-x` has the sames moves as `-y`. |
Identical.of_neg : ∀ {x₁ x₂ : PGame}, -x₁ ≡ -x₂ → x₁ ≡ x₂
| mk x₁l x₁r x₁L x₁R, mk x₂l x₂r x₂L x₂R => by
simpa using Identical.neg (x₁ := mk _ _ (-x₁R ·) (-x₁L ·)) (x₂ := mk _ _ (-x₂R ·) (-x₂L ·)) | lemma | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | Identical.of_neg | If `-x` has the same moves as `-y`, then `x` has the sames moves as `y`. |
memₗ_neg_iff : ∀ {x y : PGame},
x ∈ₗ -y ↔ ∃ z ∈ᵣ y, x ≡ -z
| mk _ _ _ _, mk _ _ _ _ =>
⟨fun ⟨_i, hi⟩ ↦ ⟨_, ⟨_, refl _⟩, hi⟩, fun ⟨_, ⟨i, hi⟩, h⟩ ↦ ⟨i, h.trans hi.neg⟩⟩ | lemma | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | memₗ_neg_iff | null |
memᵣ_neg_iff : ∀ {x y : PGame},
x ∈ᵣ -y ↔ ∃ z ∈ₗ y, x ≡ -z
| mk _ _ _ _, mk _ _ _ _ =>
⟨fun ⟨_i, hi⟩ ↦ ⟨_, ⟨_, refl _⟩, hi⟩, fun ⟨_, ⟨i, hi⟩, h⟩ ↦ ⟨i, h.trans hi.neg⟩⟩ | lemma | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | memᵣ_neg_iff | null |
Relabelling.negCongr : ∀ {x y : PGame}, x ≡r y → -x ≡r -y
| ⟨_, _, _, _⟩, ⟨_, _, _, _⟩, ⟨L, R, hL, hR⟩ =>
⟨R, L, fun j => (hR j).negCongr, fun i => (hL i).negCongr⟩ | def | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | Relabelling.negCongr | If `x` has the same moves as `y`, then `-x` has the same moves as `-y`. |
private neg_le_lf_neg_iff : ∀ {x y : PGame.{u}}, (-y ≤ -x ↔ x ≤ y) ∧ (-y ⧏ -x ↔ x ⧏ y)
| mk xl xr xL xR, mk yl yr yL yR => by
simp_rw [neg_def, mk_le_mk, mk_lf_mk, ← neg_def]
constructor
· rw [and_comm]
apply and_congr <;> exact forall_congr' fun _ => neg_le_lf_neg_iff.2
· rw [or_comm]
apply or_congr <;> exact exists_congr fun _ => neg_le_lf_neg_iff.1
termination_by x y => (x, y)
@[simp] | theorem | SetTheory | [
"Mathlib.Algebra.Order.ZeroLEOne",
"Mathlib.SetTheory.PGame.Order",
"Mathlib.Data.Nat.Cast.Defs",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Algebra.lean | neg_le_lf_neg_iff | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.