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 ⌀ |
|---|---|---|---|---|---|---|
moveRightSymm :
∀ (r : x ≡r y) (i : y.RightMoves), x.moveRight (r.rightMovesEquiv.symm i) ≡r y.moveRight i
| ⟨L, R, hL, hR⟩, i => by simpa using hR (R.symm i) | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | moveRightSymm | A right move of `y` is a relabelling of a right move of `x`. |
@[refl]
refl (x : PGame) : x ≡r x :=
⟨Equiv.refl _, Equiv.refl _, fun _ => refl _, fun _ => refl _⟩
termination_by x | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | refl | The identity relabelling. |
@[symm]
symm : ∀ {x y : PGame}, x ≡r y → y ≡r x
| _, _, ⟨L, R, hL, hR⟩ => mk' L R (fun i => (hL i).symm) fun j => (hR j).symm | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | symm | Flip a relabelling. |
@[trans]
trans : ∀ {x y z : PGame}, x ≡r y → y ≡r z → x ≡r z
| _, _, _, ⟨L₁, R₁, hL₁, hR₁⟩, ⟨L₂, R₂, hL₂, hR₂⟩ =>
⟨L₁.trans L₂, R₁.trans R₂, fun i => (hL₁ i).trans (hL₂ _), fun j => (hR₁ j).trans (hR₂ _)⟩ | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | trans | Transitivity of relabelling. |
isEmpty (x : PGame) [IsEmpty x.LeftMoves] [IsEmpty x.RightMoves] : x ≡r 0 :=
⟨Equiv.equivPEmpty _, Equiv.equivOfIsEmpty _ _, isEmptyElim, isEmptyElim⟩ | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | isEmpty | Any game without left or right moves is a relabelling of 0. |
relabel {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) : PGame :=
⟨xl', xr', x.moveLeft ∘ el, x.moveRight ∘ er⟩
@[simp] | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | relabel | Replace the types indexing the next moves for Left and Right by equivalent types. |
relabel_moveLeft' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
(i : xl') : moveLeft (relabel el er) i = x.moveLeft (el i) :=
rfl | theorem | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | relabel_moveLeft' | null |
relabel_moveLeft {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
(i : x.LeftMoves) : moveLeft (relabel el er) (el.symm i) = x.moveLeft i := by simp
@[simp] | theorem | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | relabel_moveLeft | null |
relabel_moveRight' {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
(j : xr') : moveRight (relabel el er) j = x.moveRight (er j) :=
rfl | theorem | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | relabel_moveRight' | null |
relabel_moveRight {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves)
(j : x.RightMoves) : moveRight (relabel el er) (er.symm j) = x.moveRight j := by simp | theorem | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | relabel_moveRight | null |
relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
x ≡r relabel el er :=
Relabelling.mk' el er (fun i => by simp; rfl) (fun j => by simp; rfl)
/-! ### Inserting an option -/ | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | relabelRelabelling | The game obtained by relabelling the next moves is a relabelling of the original game. |
insertLeft (x x' : PGame.{u}) : PGame :=
match x with
| mk xl xr xL xR => mk (xl ⊕ PUnit) xr (Sum.elim xL fun _ => x') xR | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | insertLeft | The pregame constructed by inserting `x'` as a new left option into x. |
insertRight (x x' : PGame.{u}) : PGame :=
match x with
| mk xl xr xL xR => mk xl (xr ⊕ PUnit) xL (Sum.elim xR fun _ => x') | def | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | insertRight | The pregame constructed by inserting `x'` as a new right option into x. |
insertRight_insertLeft {x x' x'' : PGame} :
insertRight (insertLeft x x') x'' = insertLeft (insertRight x x'') x' := by
cases x; cases x'; cases x''
dsimp [insertLeft, insertRight] | theorem | SetTheory | [
"Mathlib.Data.Nat.Basic",
"Mathlib.Logic.Equiv.Defs",
"Mathlib.Tactic.Convert",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Basic.lean | insertRight_insertLeft | Inserting on the left and right commutes. |
le : LE PGame :=
⟨Sym2.GameAdd.fix wf_isOption fun x y le =>
(∀ i, ¬le y (x.moveLeft i) (Sym2.GameAdd.snd_fst <| IsOption.moveLeft i)) ∧
∀ j, ¬le (y.moveRight j) x (Sym2.GameAdd.fst_snd <| IsOption.moveRight j)⟩ | instance | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le | The less or equal relation on pre-games.
If `0 ≤ x`, then Left can win `x` as the second player. `x ≤ y` means that `0 ≤ y - x`.
See `PGame.le_iff_sub_nonneg`. |
LF (x y : PGame) : Prop :=
¬y ≤ x
@[inherit_doc]
scoped infixl:50 " ⧏ " => PGame.LF
@[simp] | def | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | LF | The less or fuzzy relation on pre-games. `x ⧏ y` is defined as `¬ y ≤ x`.
If `0 ⧏ x`, then Left can win `x` as the first player. `x ⧏ y` means that `0 ⧏ y - x`.
See `PGame.lf_iff_sub_zero_lf`. |
protected not_le {x y : PGame} : ¬x ≤ y ↔ y ⧏ x :=
Iff.rfl
@[simp] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | not_le | null |
not_lf {x y : PGame} : ¬x ⧏ y ↔ y ≤ x :=
Classical.not_not | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | not_lf | null |
_root_.LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x :=
not_lf.2 | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | _root_.LE.le.not_gf | null |
LF.not_ge {x y : PGame} : x ⧏ y → ¬y ≤ x :=
id | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | LF.not_ge | null |
le_iff_forall_lf {x y : PGame} :
x ≤ y ↔ (∀ i, x.moveLeft i ⧏ y) ∧ ∀ j, x ⧏ y.moveRight j := by
unfold LE.le le
simp only
rw [Sym2.GameAdd.fix_eq]
rfl | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_iff_forall_lf | Definition of `x ≤ y` on pre-games, in terms of `⧏`.
The ordering here is chosen so that `And.left` refer to moves by Left, and `And.right` refer to
moves by Right. |
@[simp]
mk_le_mk {xl xr xL xR yl yr yL yR} :
mk xl xr xL xR ≤ mk yl yr yL yR ↔ (∀ i, xL i ⧏ mk yl yr yL yR) ∧ ∀ j, mk xl xr xL xR ⧏ yR j :=
le_iff_forall_lf | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | mk_le_mk | Definition of `x ≤ y` on pre-games built using the constructor. |
le_of_forall_lf {x y : PGame} (h₁ : ∀ i, x.moveLeft i ⧏ y) (h₂ : ∀ j, x ⧏ y.moveRight j) :
x ≤ y :=
le_iff_forall_lf.2 ⟨h₁, h₂⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_of_forall_lf | null |
lf_iff_exists_le {x y : PGame} :
x ⧏ y ↔ (∃ i, x ≤ y.moveLeft i) ∨ ∃ j, x.moveRight j ≤ y := by
rw [LF, le_iff_forall_lf, not_and_or]
simp | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_iff_exists_le | Definition of `x ⧏ y` on pre-games, in terms of `≤`.
The ordering here is chosen so that `or.inl` refer to moves by Left, and `or.inr` refer to
moves by Right. |
@[simp]
mk_lf_mk {xl xr xL xR yl yr yL yR} :
mk xl xr xL xR ⧏ mk yl yr yL yR ↔ (∃ i, mk xl xr xL xR ≤ yL i) ∨ ∃ j, xR j ≤ mk yl yr yL yR :=
lf_iff_exists_le | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | mk_lf_mk | Definition of `x ⧏ y` on pre-games built using the constructor. |
le_or_gf (x y : PGame) : x ≤ y ∨ y ⧏ x := by
rw [← PGame.not_le]
apply em | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_or_gf | null |
moveLeft_lf_of_le {x y : PGame} (h : x ≤ y) (i) : x.moveLeft i ⧏ y :=
(le_iff_forall_lf.1 h).1 i
alias _root_.LE.le.moveLeft_lf := moveLeft_lf_of_le | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | moveLeft_lf_of_le | null |
lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j :=
(le_iff_forall_lf.1 h).2 j
alias _root_.LE.le.lf_moveRight := lf_moveRight_of_le | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_moveRight_of_le | null |
lf_of_moveRight_le {x y : PGame} {j} (h : x.moveRight j ≤ y) : x ⧏ y :=
lf_iff_exists_le.2 <| Or.inr ⟨j, h⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_moveRight_le | null |
lf_of_le_moveLeft {x y : PGame} {i} (h : x ≤ y.moveLeft i) : x ⧏ y :=
lf_iff_exists_le.2 <| Or.inl ⟨i, h⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_le_moveLeft | null |
lf_of_le_mk {xl xr xL xR y} : mk xl xr xL xR ≤ y → ∀ i, xL i ⧏ y :=
moveLeft_lf_of_le | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_le_mk | null |
lf_of_mk_le {x yl yr yL yR} : x ≤ mk yl yr yL yR → ∀ j, x ⧏ yR j :=
lf_moveRight_of_le | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_mk_le | null |
mk_lf_of_le {xl xr y j} (xL) {xR : xr → PGame} : xR j ≤ y → mk xl xr xL xR ⧏ y :=
@lf_of_moveRight_le (mk _ _ _ _) y j | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | mk_lf_of_le | null |
lf_mk_of_le {x yl yr} {yL : yl → PGame} (yR) {i} : x ≤ yL i → x ⧏ mk yl yr yL yR :=
@lf_of_le_moveLeft x (mk _ _ _ _) i
/- We prove that `x ≤ y → y ≤ z → x ≤ z` inductively, by also simultaneously proving its cyclic
reorderings. This auxiliary lemma is used during said induction. -/ | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_mk_of_le | null |
private le_trans_aux {x y z : PGame}
(h₁ : ∀ {i}, y ≤ z → z ≤ x.moveLeft i → y ≤ x.moveLeft i)
(h₂ : ∀ {j}, z.moveRight j ≤ x → x ≤ y → z.moveRight j ≤ y) (hxy : x ≤ y) (hyz : y ≤ z) :
x ≤ z :=
le_of_forall_lf (fun i => PGame.not_le.1 fun h => (h₁ hyz h).not_gf <| hxy.moveLeft_lf i)
fun j => PGame.not_le.1 fun h => (h₂ h hxy).not_gf <| hyz.lf_moveRight j | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_trans_aux | null |
Identical.le : ∀ {x y}, x ≡ y → x ≤ y
| mk _ _ _ _, mk _ _ _ _, ⟨hL, hR⟩ => le_of_forall_lf
(fun i ↦ let ⟨_, hj⟩ := hL.1 i; lf_of_le_moveLeft hj.le)
(fun i ↦ let ⟨_, hj⟩ := hR.2 i; lf_of_moveRight_le hj.le) | lemma | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | Identical.le | null |
Identical.ge {x y} (h : x ≡ y) : y ≤ x := h.symm.le | lemma | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | Identical.ge | null |
lt_iff_le_and_lf {x y : PGame} : x < y ↔ x ≤ y ∧ x ⧏ y :=
Iff.rfl | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lt_iff_le_and_lf | null |
lt_of_le_of_lf {x y : PGame} (h₁ : x ≤ y) (h₂ : x ⧏ y) : x < y :=
⟨h₁, h₂⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lt_of_le_of_lf | null |
lf_of_lt {x y : PGame} (h : x < y) : x ⧏ y :=
h.2
alias _root_.LT.lt.lf := lf_of_lt | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_lt | null |
lf_irrefl (x : PGame) : ¬x ⧏ x :=
le_rfl.not_gf | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_irrefl | null |
protected not_lt {x y : PGame} : ¬ x < y ↔ y ⧏ x ∨ y ≤ x := not_lt_iff_not_le_or_ge
@[trans] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | not_lt | null |
lf_of_le_of_lf {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ⧏ z) : x ⧏ z := by
rw [← PGame.not_le] at h₂ ⊢
exact fun h₃ => h₂ (h₃.trans h₁) | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_le_of_lf | null |
@[trans]
lf_of_lf_of_le {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≤ z) : x ⧏ z := by
rw [← PGame.not_le] at h₁ ⊢
exact fun h₃ => h₁ (h₂.trans h₃) | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_lf_of_le | null |
@[trans]
lf_of_lt_of_lf {x y z : PGame} (h₁ : x < y) (h₂ : y ⧏ z) : x ⧏ z :=
h₁.le.trans_lf h₂
@[trans] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_lt_of_lf | null |
lf_of_lf_of_lt {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y < z) : x ⧏ z :=
h₁.trans_le h₂.le
alias _root_.LT.lt.trans_lf := lf_of_lt_of_lf
alias LF.trans_lt := lf_of_lf_of_lt | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_lf_of_lt | null |
moveLeft_lf {x : PGame} : ∀ i, x.moveLeft i ⧏ x :=
le_rfl.moveLeft_lf | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | moveLeft_lf | null |
lf_moveRight {x : PGame} : ∀ j, x ⧏ x.moveRight j :=
le_rfl.lf_moveRight | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_moveRight | null |
lf_mk {xl xr} (xL : xl → PGame) (xR : xr → PGame) (i) : xL i ⧏ mk xl xr xL xR :=
@moveLeft_lf (mk _ _ _ _) i | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_mk | null |
mk_lf {xl xr} (xL : xl → PGame) (xR : xr → PGame) (j) : mk xl xr xL xR ⧏ xR j :=
@lf_moveRight (mk _ _ _ _) j | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | mk_lf | null |
le_of_forall_lt {x y : PGame} (h₁ : ∀ i, x.moveLeft i < y) (h₂ : ∀ j, x < y.moveRight j) :
x ≤ y :=
le_of_forall_lf (fun i => (h₁ i).lf) fun i => (h₂ i).lf | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_of_forall_lt | This special case of `PGame.le_of_forall_lf` is useful when dealing with surreals, where `<` is
preferred over `⧏`. |
le_def {x y : PGame} :
x ≤ y ↔
(∀ i, (∃ i', x.moveLeft i ≤ y.moveLeft i') ∨ ∃ j, (x.moveLeft i).moveRight j ≤ y) ∧
∀ j, (∃ i, x ≤ (y.moveRight j).moveLeft i) ∨ ∃ j', x.moveRight j' ≤ y.moveRight j := by
rw [le_iff_forall_lf]
conv =>
lhs
simp only [lf_iff_exists_le] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_def | The definition of `x ≤ y` on pre-games, in terms of `≤` two moves later.
Note that it's often more convenient to use `le_iff_forall_lf`, which only unfolds the definition by
one step. |
lf_def {x y : PGame} :
x ⧏ y ↔
(∃ i, (∀ i', x.moveLeft i' ⧏ y.moveLeft i) ∧ ∀ j, x ⧏ (y.moveLeft i).moveRight j) ∨
∃ j, (∀ i, (x.moveRight j).moveLeft i ⧏ y) ∧ ∀ j', x.moveRight j ⧏ y.moveRight j' := by
rw [lf_iff_exists_le]
conv =>
lhs
simp only [le_iff_forall_lf] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_def | The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later.
Note that it's often more convenient to use `lf_iff_exists_le`, which only unfolds the definition by
one step. |
zero_le_lf {x : PGame} : 0 ≤ x ↔ ∀ j, 0 ⧏ x.moveRight j := by
rw [le_iff_forall_lf]
simp | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | zero_le_lf | The definition of `0 ≤ x` on pre-games, in terms of `0 ⧏`. |
le_zero_lf {x : PGame} : x ≤ 0 ↔ ∀ i, x.moveLeft i ⧏ 0 := by
rw [le_iff_forall_lf]
simp | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_zero_lf | The definition of `x ≤ 0` on pre-games, in terms of `⧏ 0`. |
zero_lf_le {x : PGame} : 0 ⧏ x ↔ ∃ i, 0 ≤ x.moveLeft i := by
rw [lf_iff_exists_le]
simp | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | zero_lf_le | The definition of `0 ⧏ x` on pre-games, in terms of `0 ≤`. |
lf_zero_le {x : PGame} : x ⧏ 0 ↔ ∃ j, x.moveRight j ≤ 0 := by
rw [lf_iff_exists_le]
simp | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_zero_le | The definition of `x ⧏ 0` on pre-games, in terms of `≤ 0`. |
zero_le {x : PGame} : 0 ≤ x ↔ ∀ j, ∃ i, 0 ≤ (x.moveRight j).moveLeft i := by
rw [le_def]
simp | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | zero_le | The definition of `0 ≤ x` on pre-games, in terms of `0 ≤` two moves later. |
le_zero {x : PGame} : x ≤ 0 ↔ ∀ i, ∃ j, (x.moveLeft i).moveRight j ≤ 0 := by
rw [le_def]
simp | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_zero | The definition of `x ≤ 0` on pre-games, in terms of `≤ 0` two moves later. |
zero_lf {x : PGame} : 0 ⧏ x ↔ ∃ i, ∀ j, 0 ⧏ (x.moveLeft i).moveRight j := by
rw [lf_def]
simp | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | zero_lf | The definition of `0 ⧏ x` on pre-games, in terms of `0 ⧏` two moves later. |
lf_zero {x : PGame} : x ⧏ 0 ↔ ∃ j, ∀ i, (x.moveRight j).moveLeft i ⧏ 0 := by
rw [lf_def]
simp
@[simp] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_zero | The definition of `x ⧏ 0` on pre-games, in terms of `⧏ 0` two moves later. |
zero_le_of_isEmpty_rightMoves (x : PGame) [IsEmpty x.RightMoves] : 0 ≤ x :=
zero_le.2 isEmptyElim
@[simp] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | zero_le_of_isEmpty_rightMoves | null |
le_zero_of_isEmpty_leftMoves (x : PGame) [IsEmpty x.LeftMoves] : x ≤ 0 :=
le_zero.2 isEmptyElim | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_zero_of_isEmpty_leftMoves | null |
noncomputable rightResponse {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
(x.moveLeft i).RightMoves :=
Classical.choose <| le_zero.1 h i | def | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | rightResponse | Given a game won by the right player when they play second, provide a response to any move by
left. |
rightResponse_spec {x : PGame} (h : x ≤ 0) (i : x.LeftMoves) :
(x.moveLeft i).moveRight (rightResponse h i) ≤ 0 :=
Classical.choose_spec <| le_zero.1 h i | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | rightResponse_spec | Show that the response for right provided by `rightResponse` preserves the right-player-wins
condition. |
noncomputable leftResponse {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
(x.moveRight j).LeftMoves :=
Classical.choose <| zero_le.1 h j | def | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | leftResponse | Given a game won by the left player when they play second, provide a response to any move by
right. |
leftResponse_spec {x : PGame} (h : 0 ≤ x) (j : x.RightMoves) :
0 ≤ (x.moveRight j).moveLeft (leftResponse h j) :=
Classical.choose_spec <| zero_le.1 h j | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | leftResponse_spec | Show that the response for left provided by `leftResponse` preserves the left-player-wins
condition. |
bddAbove_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → PGame.{u}) :
BddAbove (Set.range f) := by
let x : PGame.{u} := ⟨Σ i, (f <| (equivShrink.{u} ι).symm i).LeftMoves, PEmpty,
fun x ↦ moveLeft _ x.2, PEmpty.elim⟩
refine ⟨x, Set.forall_mem_range.2 fun i ↦ ?_⟩
rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
simpa [x] using fun j ↦ @moveLeft_lf x ⟨equivShrink ι i, j⟩ | lemma | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | bddAbove_range_of_small | A small family of pre-games is bounded above. |
bddAbove_of_small (s : Set PGame.{u}) [Small.{u} s] : BddAbove s := by
simpa using bddAbove_range_of_small (Subtype.val : s → PGame.{u}) | lemma | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | bddAbove_of_small | A small set of pre-games is bounded above. |
bddBelow_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → PGame.{u}) :
BddBelow (Set.range f) := by
let x : PGame.{u} := ⟨PEmpty, Σ i, (f <| (equivShrink.{u} ι).symm i).RightMoves, PEmpty.elim,
fun x ↦ moveRight _ x.2⟩
refine ⟨x, Set.forall_mem_range.2 fun i ↦ ?_⟩
rw [← (equivShrink ι).symm_apply_apply i, le_iff_forall_lf]
simpa [x] using fun j ↦ @lf_moveRight x ⟨equivShrink ι i, j⟩ | lemma | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | bddBelow_range_of_small | A small family of pre-games is bounded below. |
bddBelow_of_small (s : Set PGame.{u}) [Small.{u} s] : BddBelow s := by
simpa using bddBelow_range_of_small (Subtype.val : s → PGame.{u}) | lemma | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | bddBelow_of_small | A small set of pre-games is bounded below. |
Equiv (x y : PGame) : Prop :=
x ≤ y ∧ y ≤ x | def | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | Equiv | The equivalence relation on pre-games. Two pre-games `x`, `y` are equivalent if `x ≤ y` and
`y ≤ x`.
If `x ≈ 0`, then the second player can always win `x`. |
setoid : Setoid PGame :=
⟨Equiv, refl, symm, Trans.trans⟩ | instance | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | setoid | null |
equiv_def {x y : PGame} : x ≈ y ↔ x ≤ y ∧ y ≤ x := Iff.rfl | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | equiv_def | null |
Equiv.le {x y : PGame} (h : x ≈ y) : x ≤ y :=
h.1 | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | Equiv.le | null |
Equiv.ge {x y : PGame} (h : x ≈ y) : y ≤ x :=
h.2 | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | Equiv.ge | null |
equiv_rfl {x : PGame} : x ≈ x :=
refl x | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | equiv_rfl | null |
equiv_refl (x : PGame) : x ≈ x :=
refl x
@[symm] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | equiv_refl | null |
protected Equiv.symm {x y : PGame} : (x ≈ y) → (y ≈ x) :=
symm
@[trans] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | Equiv.symm | null |
protected Equiv.trans {x y z : PGame} : (x ≈ y) → (y ≈ z) → (x ≈ z) :=
_root_.trans | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | Equiv.trans | null |
protected equiv_comm {x y : PGame} : (x ≈ y) ↔ (y ≈ x) :=
comm | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | equiv_comm | null |
equiv_of_eq {x y : PGame} (h : x = y) : x ≈ y := by subst h; rfl | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | equiv_of_eq | null |
Identical.equiv {x y} (h : x ≡ y) : x ≈ y := ⟨h.le, h.ge⟩
@[trans] | lemma | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | Identical.equiv | null |
le_of_le_of_equiv {x y z : PGame} (h₁ : x ≤ y) (h₂ : y ≈ z) : x ≤ z :=
h₁.trans h₂.1 | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_of_le_of_equiv | null |
@[trans]
le_of_equiv_of_le {x y z : PGame} (h₁ : x ≈ y) : y ≤ z → x ≤ z :=
h₁.1.trans | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_of_equiv_of_le | null |
LF.not_equiv {x y : PGame} (h : x ⧏ y) : ¬(x ≈ y) := fun h' => h.not_ge h'.2 | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | LF.not_equiv | null |
LF.not_equiv' {x y : PGame} (h : x ⧏ y) : ¬(y ≈ x) := fun h' => h.not_ge h'.1 | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | LF.not_equiv' | null |
LF.not_gt {x y : PGame} (h : x ⧏ y) : ¬y < x := fun h' => h.not_ge h'.le | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | LF.not_gt | null |
le_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) (h : x₁ ≤ y₁) : x₂ ≤ y₂ :=
hx.2.trans (h.trans hy.1) | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_congr_imp | null |
le_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ≤ y₁ ↔ x₂ ≤ y₂ :=
⟨le_congr_imp hx hy, le_congr_imp (Equiv.symm hx) (Equiv.symm hy)⟩ | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_congr | null |
le_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ≤ y ↔ x₂ ≤ y :=
le_congr hx equiv_rfl | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_congr_left | null |
le_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ≤ y₁ ↔ x ≤ y₂ :=
le_congr equiv_rfl hy | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | le_congr_right | null |
lf_congr {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ ↔ x₂ ⧏ y₂ :=
PGame.not_le.symm.trans <| (not_congr (le_congr hy hx)).trans PGame.not_le | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_congr | null |
lf_congr_imp {x₁ y₁ x₂ y₂ : PGame} (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ ⧏ y₁ → x₂ ⧏ y₂ :=
(lf_congr hx hy).1 | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_congr_imp | null |
lf_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ ⧏ y ↔ x₂ ⧏ y :=
lf_congr hx equiv_rfl | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_congr_left | null |
lf_congr_right {x y₁ y₂ : PGame} (hy : y₁ ≈ y₂) : x ⧏ y₁ ↔ x ⧏ y₂ :=
lf_congr equiv_rfl hy
@[trans] | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_congr_right | null |
lf_of_lf_of_equiv {x y z : PGame} (h₁ : x ⧏ y) (h₂ : y ≈ z) : x ⧏ z :=
lf_congr_imp equiv_rfl h₂ h₁ | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_lf_of_equiv | null |
@[trans]
lf_of_equiv_of_lf {x y z : PGame} (h₁ : x ≈ y) : y ⧏ z → x ⧏ z :=
lf_congr_imp (Equiv.symm h₁) equiv_rfl | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lf_of_equiv_of_lf | null |
@[trans]
lt_of_lt_of_equiv {x y z : PGame} (h₁ : x < y) (h₂ : y ≈ z) : x < z :=
h₁.trans_le h₂.1 | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lt_of_lt_of_equiv | null |
@[trans]
lt_of_equiv_of_lt {x y z : PGame} (h₁ : x ≈ y) : y < z → x < z :=
h₁.1.trans_lt | theorem | SetTheory | [
"Mathlib.Logic.Small.Defs",
"Mathlib.Order.GameAdd",
"Mathlib.SetTheory.PGame.Basic",
"Mathlib.Tactic.Linter.DeprecatedModule"
] | Mathlib/SetTheory/PGame/Order.lean | lt_of_equiv_of_lt | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.