set_theory.game.domineering | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

b134b2f5

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

728ef9db

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -106,7 +106,7 @@ theorem SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right
     {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ}
     (h : m ∈ SetTheory.PGame.Domineering.right b) : (m.1 - 1, m.2) ∈ b.eraseₓ m :=
   by
-  rw [mem_right] at h 
+  rw [mem_right] at h
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.fst (pred_ne_self m.1)
 #align pgame.domineering.fst_pred_mem_erase_of_mem_right SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right
@@ -117,7 +117,7 @@ theorem SetTheory.PGame.Domineering.snd_pred_mem_erase_of_mem_left
     {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ}
     (h : m ∈ SetTheory.PGame.Domineering.left b) : (m.1, m.2 - 1) ∈ b.eraseₓ m :=
   by
-  rw [mem_left] at h 
+  rw [mem_left] at h
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.snd (pred_ne_self m.2)
 #align pgame.domineering.snd_pred_mem_erase_of_mem_left SetTheory.PGame.Domineering.snd_pred_mem_erase_of_mem_left
@@ -195,11 +195,11 @@ instance SetTheory.PGame.Domineering.state : SetTheory.PGame.State SetTheory.PGa
   l s := (SetTheory.PGame.Domineering.left s).image (SetTheory.PGame.Domineering.moveLeft s)
   r s := (SetTheory.PGame.Domineering.right s).image (SetTheory.PGame.Domineering.moveRight s)
   left_bound s t m := by
-    simp only [Finset.mem_image, Prod.exists] at m 
+    simp only [Finset.mem_image, Prod.exists] at m
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
     exact move_left_smaller h
   right_bound s t m := by
-    simp only [Finset.mem_image, Prod.exists] at m 
+    simp only [Finset.mem_image, Prod.exists] at m
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
     exact move_right_smaller h
 #align pgame.domineering.state SetTheory.PGame.Domineering.state

728ef9db

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathbin.SetTheory.Game.State
+import SetTheory.Game.State
 
 #align_import set_theory.game.domineering from "leanprover-community/mathlib"@"728ef9dbb281241906f25cbeb30f90d83e0bb451"

728ef9db

bump to nightly-2023-09-02-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/442a83d738cb208d3600056c489be16900ba701d

a4ca67cb

Diff

@@ -25,158 +25,175 @@ disjoint parts of the chessboard give sums of games.
 -/
 
 
-namespace PGame
+namespace SetTheory.PGame
 
 namespace Domineering
 
 open Function
 
-#print PGame.Domineering.shiftUp /-
+#print SetTheory.PGame.Domineering.shiftUp /-
 /-- The equivalence `(x, y) ↦ (x, y+1)`. -/
 @[simps]
-def shiftUp : ℤ × ℤ ≃ ℤ × ℤ :=
+def SetTheory.PGame.Domineering.shiftUp : ℤ × ℤ ≃ ℤ × ℤ :=
   (Equiv.refl ℤ).prodCongr (Equiv.addRight (1 : ℤ))
-#align pgame.domineering.shift_up PGame.Domineering.shiftUp
+#align pgame.domineering.shift_up SetTheory.PGame.Domineering.shiftUp
 -/
 
-#print PGame.Domineering.shiftRight /-
+#print SetTheory.PGame.Domineering.shiftRight /-
 /-- The equivalence `(x, y) ↦ (x+1, y)`. -/
 @[simps]
-def shiftRight : ℤ × ℤ ≃ ℤ × ℤ :=
+def SetTheory.PGame.Domineering.shiftRight : ℤ × ℤ ≃ ℤ × ℤ :=
   (Equiv.addRight (1 : ℤ)).prodCongr (Equiv.refl ℤ)
-#align pgame.domineering.shift_right PGame.Domineering.shiftRight
+#align pgame.domineering.shift_right SetTheory.PGame.Domineering.shiftRight
 -/
 
-#print PGame.Domineering.Board /-
+#print SetTheory.PGame.Domineering.Board /-
 /-- A Domineering board is an arbitrary finite subset of `ℤ × ℤ`. -/
-def Board :=
+def SetTheory.PGame.Domineering.Board :=
   Finset (ℤ × ℤ)
 deriving Inhabited
-#align pgame.domineering.board PGame.Domineering.Board
+#align pgame.domineering.board SetTheory.PGame.Domineering.Board
 -/
 
 attribute [local reducible] board
 
-#print PGame.Domineering.left /-
+#print SetTheory.PGame.Domineering.left /-
 /-- Left can play anywhere that a square and the square below it are open. -/
-def left (b : Board) : Finset (ℤ × ℤ) :=
-  b ∩ b.map shiftUp
-#align pgame.domineering.left PGame.Domineering.left
+def SetTheory.PGame.Domineering.left (b : SetTheory.PGame.Domineering.Board) : Finset (ℤ × ℤ) :=
+  b ∩ b.map SetTheory.PGame.Domineering.shiftUp
+#align pgame.domineering.left SetTheory.PGame.Domineering.left
 -/
 
-#print PGame.Domineering.right /-
+#print SetTheory.PGame.Domineering.right /-
 /-- Right can play anywhere that a square and the square to the left are open. -/
-def right (b : Board) : Finset (ℤ × ℤ) :=
-  b ∩ b.map shiftRight
-#align pgame.domineering.right PGame.Domineering.right
+def SetTheory.PGame.Domineering.right (b : SetTheory.PGame.Domineering.Board) : Finset (ℤ × ℤ) :=
+  b ∩ b.map SetTheory.PGame.Domineering.shiftRight
+#align pgame.domineering.right SetTheory.PGame.Domineering.right
 -/
 
-#print PGame.Domineering.mem_left /-
-theorem mem_left {b : Board} (x : ℤ × ℤ) : x ∈ left b ↔ x ∈ b ∧ (x.1, x.2 - 1) ∈ b :=
+#print SetTheory.PGame.Domineering.mem_left /-
+theorem SetTheory.PGame.Domineering.mem_left {b : SetTheory.PGame.Domineering.Board} (x : ℤ × ℤ) :
+    x ∈ SetTheory.PGame.Domineering.left b ↔ x ∈ b ∧ (x.1, x.2 - 1) ∈ b :=
   Finset.mem_inter.trans (and_congr Iff.rfl Finset.mem_map_equiv)
-#align pgame.domineering.mem_left PGame.Domineering.mem_left
+#align pgame.domineering.mem_left SetTheory.PGame.Domineering.mem_left
 -/
 
-#print PGame.Domineering.mem_right /-
-theorem mem_right {b : Board} (x : ℤ × ℤ) : x ∈ right b ↔ x ∈ b ∧ (x.1 - 1, x.2) ∈ b :=
+#print SetTheory.PGame.Domineering.mem_right /-
+theorem SetTheory.PGame.Domineering.mem_right {b : SetTheory.PGame.Domineering.Board} (x : ℤ × ℤ) :
+    x ∈ SetTheory.PGame.Domineering.right b ↔ x ∈ b ∧ (x.1 - 1, x.2) ∈ b :=
   Finset.mem_inter.trans (and_congr Iff.rfl Finset.mem_map_equiv)
-#align pgame.domineering.mem_right PGame.Domineering.mem_right
+#align pgame.domineering.mem_right SetTheory.PGame.Domineering.mem_right
 -/
 
-#print PGame.Domineering.moveLeft /-
+#print SetTheory.PGame.Domineering.moveLeft /-
 /-- After Left moves, two vertically adjacent squares are removed from the board. -/
-def moveLeft (b : Board) (m : ℤ × ℤ) : Board :=
+def SetTheory.PGame.Domineering.moveLeft (b : SetTheory.PGame.Domineering.Board) (m : ℤ × ℤ) :
+    SetTheory.PGame.Domineering.Board :=
   (b.eraseₓ m).eraseₓ (m.1, m.2 - 1)
-#align pgame.domineering.move_left PGame.Domineering.moveLeft
+#align pgame.domineering.move_left SetTheory.PGame.Domineering.moveLeft
 -/
 
-#print PGame.Domineering.moveRight /-
+#print SetTheory.PGame.Domineering.moveRight /-
 /-- After Left moves, two horizontally adjacent squares are removed from the board. -/
-def moveRight (b : Board) (m : ℤ × ℤ) : Board :=
+def SetTheory.PGame.Domineering.moveRight (b : SetTheory.PGame.Domineering.Board) (m : ℤ × ℤ) :
+    SetTheory.PGame.Domineering.Board :=
   (b.eraseₓ m).eraseₓ (m.1 - 1, m.2)
-#align pgame.domineering.move_right PGame.Domineering.moveRight
+#align pgame.domineering.move_right SetTheory.PGame.Domineering.moveRight
 -/
 
-#print PGame.Domineering.fst_pred_mem_erase_of_mem_right /-
-theorem fst_pred_mem_erase_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
-    (m.1 - 1, m.2) ∈ b.eraseₓ m := by
+#print SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right /-
+theorem SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right
+    {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ}
+    (h : m ∈ SetTheory.PGame.Domineering.right b) : (m.1 - 1, m.2) ∈ b.eraseₓ m :=
+  by
   rw [mem_right] at h 
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.fst (pred_ne_self m.1)
-#align pgame.domineering.fst_pred_mem_erase_of_mem_right PGame.Domineering.fst_pred_mem_erase_of_mem_right
+#align pgame.domineering.fst_pred_mem_erase_of_mem_right SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right
 -/
 
-#print PGame.Domineering.snd_pred_mem_erase_of_mem_left /-
-theorem snd_pred_mem_erase_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
-    (m.1, m.2 - 1) ∈ b.eraseₓ m := by
+#print SetTheory.PGame.Domineering.snd_pred_mem_erase_of_mem_left /-
+theorem SetTheory.PGame.Domineering.snd_pred_mem_erase_of_mem_left
+    {b : SetTheory.PGame.Domineering.Board} {m : ℤ × ℤ}
+    (h : m ∈ SetTheory.PGame.Domineering.left b) : (m.1, m.2 - 1) ∈ b.eraseₓ m :=
+  by
   rw [mem_left] at h 
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.snd (pred_ne_self m.2)
-#align pgame.domineering.snd_pred_mem_erase_of_mem_left PGame.Domineering.snd_pred_mem_erase_of_mem_left
+#align pgame.domineering.snd_pred_mem_erase_of_mem_left SetTheory.PGame.Domineering.snd_pred_mem_erase_of_mem_left
 -/
 
-#print PGame.Domineering.card_of_mem_left /-
-theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤ Finset.card b :=
+#print SetTheory.PGame.Domineering.card_of_mem_left /-
+theorem SetTheory.PGame.Domineering.card_of_mem_left {b : SetTheory.PGame.Domineering.Board}
+    {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.left b) : 2 ≤ Finset.card b :=
   by
   have w₁ : m ∈ b := (Finset.mem_inter.1 h).1
   have w₂ : (m.1, m.2 - 1) ∈ b.erase m := snd_pred_mem_erase_of_mem_left h
   have i₁ := Finset.card_erase_lt_of_mem w₁
   have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
   exact Nat.lt_of_le_of_lt i₂ i₁
-#align pgame.domineering.card_of_mem_left PGame.Domineering.card_of_mem_left
+#align pgame.domineering.card_of_mem_left SetTheory.PGame.Domineering.card_of_mem_left
 -/
 
-#print PGame.Domineering.card_of_mem_right /-
-theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 ≤ Finset.card b :=
+#print SetTheory.PGame.Domineering.card_of_mem_right /-
+theorem SetTheory.PGame.Domineering.card_of_mem_right {b : SetTheory.PGame.Domineering.Board}
+    {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.right b) : 2 ≤ Finset.card b :=
   by
   have w₁ : m ∈ b := (Finset.mem_inter.1 h).1
   have w₂ := fst_pred_mem_erase_of_mem_right h
   have i₁ := Finset.card_erase_lt_of_mem w₁
   have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
   exact Nat.lt_of_le_of_lt i₂ i₁
-#align pgame.domineering.card_of_mem_right PGame.Domineering.card_of_mem_right
+#align pgame.domineering.card_of_mem_right SetTheory.PGame.Domineering.card_of_mem_right
 -/
 
-#print PGame.Domineering.moveLeft_card /-
-theorem moveLeft_card {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
-    Finset.card (moveLeft b m) + 2 = Finset.card b :=
+#print SetTheory.PGame.Domineering.moveLeft_card /-
+theorem SetTheory.PGame.Domineering.moveLeft_card {b : SetTheory.PGame.Domineering.Board}
+    {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.left b) :
+    Finset.card (SetTheory.PGame.Domineering.moveLeft b m) + 2 = Finset.card b :=
   by
   dsimp [move_left]
   rw [Finset.card_erase_of_mem (snd_pred_mem_erase_of_mem_left h)]
   rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
   exact tsub_add_cancel_of_le (card_of_mem_left h)
-#align pgame.domineering.move_left_card PGame.Domineering.moveLeft_card
+#align pgame.domineering.move_left_card SetTheory.PGame.Domineering.moveLeft_card
 -/
 
-#print PGame.Domineering.moveRight_card /-
-theorem moveRight_card {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
-    Finset.card (moveRight b m) + 2 = Finset.card b :=
+#print SetTheory.PGame.Domineering.moveRight_card /-
+theorem SetTheory.PGame.Domineering.moveRight_card {b : SetTheory.PGame.Domineering.Board}
+    {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.right b) :
+    Finset.card (SetTheory.PGame.Domineering.moveRight b m) + 2 = Finset.card b :=
   by
   dsimp [move_right]
   rw [Finset.card_erase_of_mem (fst_pred_mem_erase_of_mem_right h)]
   rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
   exact tsub_add_cancel_of_le (card_of_mem_right h)
-#align pgame.domineering.move_right_card PGame.Domineering.moveRight_card
+#align pgame.domineering.move_right_card SetTheory.PGame.Domineering.moveRight_card
 -/
 
-#print PGame.Domineering.moveLeft_smaller /-
-theorem moveLeft_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
-    Finset.card (moveLeft b m) / 2 < Finset.card b / 2 := by simp [← move_left_card h, lt_add_one]
-#align pgame.domineering.move_left_smaller PGame.Domineering.moveLeft_smaller
+#print SetTheory.PGame.Domineering.moveLeft_smaller /-
+theorem SetTheory.PGame.Domineering.moveLeft_smaller {b : SetTheory.PGame.Domineering.Board}
+    {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.left b) :
+    Finset.card (SetTheory.PGame.Domineering.moveLeft b m) / 2 < Finset.card b / 2 := by
+  simp [← move_left_card h, lt_add_one]
+#align pgame.domineering.move_left_smaller SetTheory.PGame.Domineering.moveLeft_smaller
 -/
 
-#print PGame.Domineering.moveRight_smaller /-
-theorem moveRight_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
-    Finset.card (moveRight b m) / 2 < Finset.card b / 2 := by simp [← move_right_card h, lt_add_one]
-#align pgame.domineering.move_right_smaller PGame.Domineering.moveRight_smaller
+#print SetTheory.PGame.Domineering.moveRight_smaller /-
+theorem SetTheory.PGame.Domineering.moveRight_smaller {b : SetTheory.PGame.Domineering.Board}
+    {m : ℤ × ℤ} (h : m ∈ SetTheory.PGame.Domineering.right b) :
+    Finset.card (SetTheory.PGame.Domineering.moveRight b m) / 2 < Finset.card b / 2 := by
+  simp [← move_right_card h, lt_add_one]
+#align pgame.domineering.move_right_smaller SetTheory.PGame.Domineering.moveRight_smaller
 -/
 
-#print PGame.Domineering.state /-
+#print SetTheory.PGame.Domineering.state /-
 /-- The instance describing allowed moves on a Domineering board. -/
-instance state : State Board where
+instance SetTheory.PGame.Domineering.state : SetTheory.PGame.State SetTheory.PGame.Domineering.Board
+    where
   turnBound s := s.card / 2
-  l s := (left s).image (moveLeft s)
-  r s := (right s).image (moveRight s)
+  l s := (SetTheory.PGame.Domineering.left s).image (SetTheory.PGame.Domineering.moveLeft s)
+  r s := (SetTheory.PGame.Domineering.right s).image (SetTheory.PGame.Domineering.moveRight s)
   left_bound s t m := by
     simp only [Finset.mem_image, Prod.exists] at m 
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
@@ -185,47 +202,49 @@ instance state : State Board where
     simp only [Finset.mem_image, Prod.exists] at m 
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
     exact move_right_smaller h
-#align pgame.domineering.state PGame.Domineering.state
+#align pgame.domineering.state SetTheory.PGame.Domineering.state
 -/
 
 end Domineering
 
-#print PGame.domineering /-
+#print SetTheory.PGame.domineering /-
 /-- Construct a pre-game from a Domineering board. -/
-def domineering (b : Domineering.Board) : PGame :=
-  PGame.ofState b
-#align pgame.domineering PGame.domineering
+def SetTheory.PGame.domineering (b : SetTheory.PGame.Domineering.Board) : SetTheory.PGame :=
+  SetTheory.PGame.ofState b
+#align pgame.domineering SetTheory.PGame.domineering
 -/
 
-#print PGame.shortDomineering /-
+#print SetTheory.PGame.shortDomineering /-
 /-- All games of Domineering are short, because each move removes two squares. -/
-instance shortDomineering (b : Domineering.Board) : Short (domineering b) := by dsimp [domineering];
-  infer_instance
-#align pgame.short_domineering PGame.shortDomineering
+instance SetTheory.PGame.shortDomineering (b : SetTheory.PGame.Domineering.Board) :
+    SetTheory.PGame.Short (SetTheory.PGame.domineering b) := by dsimp [domineering]; infer_instance
+#align pgame.short_domineering SetTheory.PGame.shortDomineering
 -/
 
-#print PGame.domineering.one /-
+#print SetTheory.PGame.domineering.one /-
 /-- The Domineering board with two squares arranged vertically, in which Left has the only move. -/
-def domineering.one :=
-  domineering [(0, 0), (0, 1)].toFinset
-#align pgame.domineering.one PGame.domineering.one
+def SetTheory.PGame.domineering.one :=
+  SetTheory.PGame.domineering [(0, 0), (0, 1)].toFinset
+#align pgame.domineering.one SetTheory.PGame.domineering.one
 -/
 
-#print PGame.domineering.L /-
+#print SetTheory.PGame.domineering.L /-
 /-- The `L` shaped Domineering board, in which Left is exactly half a move ahead. -/
-def domineering.L :=
-  domineering [(0, 2), (0, 1), (0, 0), (1, 0)].toFinset
-#align pgame.domineering.L PGame.domineering.L
+def SetTheory.PGame.domineering.L :=
+  SetTheory.PGame.domineering [(0, 2), (0, 1), (0, 0), (1, 0)].toFinset
+#align pgame.domineering.L SetTheory.PGame.domineering.L
 -/
 
-#print PGame.shortOne /-
-instance shortOne : Short domineering.one := by dsimp [domineering.one]; infer_instance
-#align pgame.short_one PGame.shortOne
+#print SetTheory.PGame.shortOne /-
+instance SetTheory.PGame.shortOne : SetTheory.PGame.Short SetTheory.PGame.domineering.one := by
+  dsimp [domineering.one]; infer_instance
+#align pgame.short_one SetTheory.PGame.shortOne
 -/
 
-#print PGame.shortL /-
-instance shortL : Short domineering.L := by dsimp [domineering.L]; infer_instance
-#align pgame.short_L PGame.shortL
+#print SetTheory.PGame.shortL /-
+instance SetTheory.PGame.shortL : SetTheory.PGame.Short SetTheory.PGame.domineering.L := by
+  dsimp [domineering.L]; infer_instance
+#align pgame.short_L SetTheory.PGame.shortL
 -/
 
 -- The VM can play small games successfully:
@@ -255,5 +274,5 @@ instance shortL : Short domineering.L := by dsimp [domineering.L]; infer_instanc
 --   (3,0), (3,1), (3,2), (3,3), (3,4),
 --   (4,0), (4,1), (4,2), (4,3), (4,4)
 --   ].to_finset) ≈ 0)
-end PGame
+end SetTheory.PGame

728ef9db

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module set_theory.game.domineering
-! leanprover-community/mathlib commit 728ef9dbb281241906f25cbeb30f90d83e0bb451
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.SetTheory.Game.State
 
+#align_import set_theory.game.domineering from "leanprover-community/mathlib"@"728ef9dbb281241906f25cbeb30f90d83e0bb451"
+
 /-!
 # Domineering as a combinatorial game.

728ef9db

bump to nightly-2023-07-04-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/728ef9dbb281241906f25cbeb30f90d83e0bb451

05318d71

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 
 ! This file was ported from Lean 3 source module set_theory.game.domineering
-! leanprover-community/mathlib commit b134b2f5cf6dd25d4bbfd3c498b6e36c11a17225
+! leanprover-community/mathlib commit 728ef9dbb281241906f25cbeb30f90d83e0bb451
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.SetTheory.Game.State
 /-!
 # Domineering as a combinatorial game.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We define the game of Domineering, played on a chessboard of arbitrary shape
 (possibly even disconnected).
 Left moves by placing a domino vertically, while Right moves by placing a domino horizontally.

b134b2f5

bump to nightly-2023-07-02-13

mathlib commit https://github.com/leanprover-community/mathlib/commit/9240e8be927a0955b9a82c6c85ef499ee3a626b8

f2dc9aa7

Diff

@@ -31,68 +31,91 @@ namespace Domineering
 
 open Function
 
+#print PGame.Domineering.shiftUp /-
 /-- The equivalence `(x, y) ↦ (x, y+1)`. -/
 @[simps]
 def shiftUp : ℤ × ℤ ≃ ℤ × ℤ :=
   (Equiv.refl ℤ).prodCongr (Equiv.addRight (1 : ℤ))
 #align pgame.domineering.shift_up PGame.Domineering.shiftUp
+-/
 
+#print PGame.Domineering.shiftRight /-
 /-- The equivalence `(x, y) ↦ (x+1, y)`. -/
 @[simps]
 def shiftRight : ℤ × ℤ ≃ ℤ × ℤ :=
   (Equiv.addRight (1 : ℤ)).prodCongr (Equiv.refl ℤ)
 #align pgame.domineering.shift_right PGame.Domineering.shiftRight
+-/
 
+#print PGame.Domineering.Board /-
 /-- A Domineering board is an arbitrary finite subset of `ℤ × ℤ`. -/
 def Board :=
   Finset (ℤ × ℤ)
 deriving Inhabited
 #align pgame.domineering.board PGame.Domineering.Board
+-/
 
 attribute [local reducible] board
 
+#print PGame.Domineering.left /-
 /-- Left can play anywhere that a square and the square below it are open. -/
 def left (b : Board) : Finset (ℤ × ℤ) :=
   b ∩ b.map shiftUp
 #align pgame.domineering.left PGame.Domineering.left
+-/
 
+#print PGame.Domineering.right /-
 /-- Right can play anywhere that a square and the square to the left are open. -/
 def right (b : Board) : Finset (ℤ × ℤ) :=
   b ∩ b.map shiftRight
 #align pgame.domineering.right PGame.Domineering.right
+-/
 
+#print PGame.Domineering.mem_left /-
 theorem mem_left {b : Board} (x : ℤ × ℤ) : x ∈ left b ↔ x ∈ b ∧ (x.1, x.2 - 1) ∈ b :=
   Finset.mem_inter.trans (and_congr Iff.rfl Finset.mem_map_equiv)
 #align pgame.domineering.mem_left PGame.Domineering.mem_left
+-/
 
+#print PGame.Domineering.mem_right /-
 theorem mem_right {b : Board} (x : ℤ × ℤ) : x ∈ right b ↔ x ∈ b ∧ (x.1 - 1, x.2) ∈ b :=
   Finset.mem_inter.trans (and_congr Iff.rfl Finset.mem_map_equiv)
 #align pgame.domineering.mem_right PGame.Domineering.mem_right
+-/
 
+#print PGame.Domineering.moveLeft /-
 /-- After Left moves, two vertically adjacent squares are removed from the board. -/
 def moveLeft (b : Board) (m : ℤ × ℤ) : Board :=
   (b.eraseₓ m).eraseₓ (m.1, m.2 - 1)
 #align pgame.domineering.move_left PGame.Domineering.moveLeft
+-/
 
+#print PGame.Domineering.moveRight /-
 /-- After Left moves, two horizontally adjacent squares are removed from the board. -/
 def moveRight (b : Board) (m : ℤ × ℤ) : Board :=
   (b.eraseₓ m).eraseₓ (m.1 - 1, m.2)
 #align pgame.domineering.move_right PGame.Domineering.moveRight
+-/
 
+#print PGame.Domineering.fst_pred_mem_erase_of_mem_right /-
 theorem fst_pred_mem_erase_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     (m.1 - 1, m.2) ∈ b.eraseₓ m := by
   rw [mem_right] at h 
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.fst (pred_ne_self m.1)
 #align pgame.domineering.fst_pred_mem_erase_of_mem_right PGame.Domineering.fst_pred_mem_erase_of_mem_right
+-/
 
+#print PGame.Domineering.snd_pred_mem_erase_of_mem_left /-
 theorem snd_pred_mem_erase_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     (m.1, m.2 - 1) ∈ b.eraseₓ m := by
   rw [mem_left] at h 
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.snd (pred_ne_self m.2)
 #align pgame.domineering.snd_pred_mem_erase_of_mem_left PGame.Domineering.snd_pred_mem_erase_of_mem_left
+-/
 
+#print PGame.Domineering.card_of_mem_left /-
 theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤ Finset.card b :=
   by
   have w₁ : m ∈ b := (Finset.mem_inter.1 h).1
@@ -101,7 +124,9 @@ theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤
   have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
   exact Nat.lt_of_le_of_lt i₂ i₁
 #align pgame.domineering.card_of_mem_left PGame.Domineering.card_of_mem_left
+-/
 
+#print PGame.Domineering.card_of_mem_right /-
 theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 ≤ Finset.card b :=
   by
   have w₁ : m ∈ b := (Finset.mem_inter.1 h).1
@@ -110,7 +135,9 @@ theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 
   have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
   exact Nat.lt_of_le_of_lt i₂ i₁
 #align pgame.domineering.card_of_mem_right PGame.Domineering.card_of_mem_right
+-/
 
+#print PGame.Domineering.moveLeft_card /-
 theorem moveLeft_card {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     Finset.card (moveLeft b m) + 2 = Finset.card b :=
   by
@@ -119,7 +146,9 @@ theorem moveLeft_card {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
   rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
   exact tsub_add_cancel_of_le (card_of_mem_left h)
 #align pgame.domineering.move_left_card PGame.Domineering.moveLeft_card
+-/
 
+#print PGame.Domineering.moveRight_card /-
 theorem moveRight_card {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     Finset.card (moveRight b m) + 2 = Finset.card b :=
   by
@@ -128,15 +157,21 @@ theorem moveRight_card {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
   rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
   exact tsub_add_cancel_of_le (card_of_mem_right h)
 #align pgame.domineering.move_right_card PGame.Domineering.moveRight_card
+-/
 
+#print PGame.Domineering.moveLeft_smaller /-
 theorem moveLeft_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     Finset.card (moveLeft b m) / 2 < Finset.card b / 2 := by simp [← move_left_card h, lt_add_one]
 #align pgame.domineering.move_left_smaller PGame.Domineering.moveLeft_smaller
+-/
 
+#print PGame.Domineering.moveRight_smaller /-
 theorem moveRight_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     Finset.card (moveRight b m) / 2 < Finset.card b / 2 := by simp [← move_right_card h, lt_add_one]
 #align pgame.domineering.move_right_smaller PGame.Domineering.moveRight_smaller
+-/
 
+#print PGame.Domineering.state /-
 /-- The instance describing allowed moves on a Domineering board. -/
 instance state : State Board where
   turnBound s := s.card / 2
@@ -151,34 +186,47 @@ instance state : State Board where
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
     exact move_right_smaller h
 #align pgame.domineering.state PGame.Domineering.state
+-/
 
 end Domineering
 
+#print PGame.domineering /-
 /-- Construct a pre-game from a Domineering board. -/
 def domineering (b : Domineering.Board) : PGame :=
   PGame.ofState b
 #align pgame.domineering PGame.domineering
+-/
 
+#print PGame.shortDomineering /-
 /-- All games of Domineering are short, because each move removes two squares. -/
 instance shortDomineering (b : Domineering.Board) : Short (domineering b) := by dsimp [domineering];
   infer_instance
 #align pgame.short_domineering PGame.shortDomineering
+-/
 
+#print PGame.domineering.one /-
 /-- The Domineering board with two squares arranged vertically, in which Left has the only move. -/
 def domineering.one :=
   domineering [(0, 0), (0, 1)].toFinset
 #align pgame.domineering.one PGame.domineering.one
+-/
 
+#print PGame.domineering.L /-
 /-- The `L` shaped Domineering board, in which Left is exactly half a move ahead. -/
-def domineering.l :=
+def domineering.L :=
   domineering [(0, 2), (0, 1), (0, 0), (1, 0)].toFinset
-#align pgame.domineering.L PGame.domineering.l
+#align pgame.domineering.L PGame.domineering.L
+-/
 
+#print PGame.shortOne /-
 instance shortOne : Short domineering.one := by dsimp [domineering.one]; infer_instance
 #align pgame.short_one PGame.shortOne
+-/
 
-instance shortL : Short domineering.l := by dsimp [domineering.L]; infer_instance
+#print PGame.shortL /-
+instance shortL : Short domineering.L := by dsimp [domineering.L]; infer_instance
 #align pgame.short_L PGame.shortL
+-/
 
 -- The VM can play small games successfully:
 -- #eval to_bool (domineering.one ≈ 1)

b134b2f5

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -45,7 +45,8 @@ def shiftRight : ℤ × ℤ ≃ ℤ × ℤ :=
 
 /-- A Domineering board is an arbitrary finite subset of `ℤ × ℤ`. -/
 def Board :=
-  Finset (ℤ × ℤ)deriving Inhabited
+  Finset (ℤ × ℤ)
+deriving Inhabited
 #align pgame.domineering.board PGame.Domineering.Board
 
 attribute [local reducible] board
@@ -80,14 +81,14 @@ def moveRight (b : Board) (m : ℤ × ℤ) : Board :=
 
 theorem fst_pred_mem_erase_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     (m.1 - 1, m.2) ∈ b.eraseₓ m := by
-  rw [mem_right] at h
+  rw [mem_right] at h 
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.fst (pred_ne_self m.1)
 #align pgame.domineering.fst_pred_mem_erase_of_mem_right PGame.Domineering.fst_pred_mem_erase_of_mem_right
 
 theorem snd_pred_mem_erase_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     (m.1, m.2 - 1) ∈ b.eraseₓ m := by
-  rw [mem_left] at h
+  rw [mem_left] at h 
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.snd (pred_ne_self m.2)
 #align pgame.domineering.snd_pred_mem_erase_of_mem_left PGame.Domineering.snd_pred_mem_erase_of_mem_left
@@ -142,11 +143,11 @@ instance state : State Board where
   l s := (left s).image (moveLeft s)
   r s := (right s).image (moveRight s)
   left_bound s t m := by
-    simp only [Finset.mem_image, Prod.exists] at m
+    simp only [Finset.mem_image, Prod.exists] at m 
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
     exact move_left_smaller h
   right_bound s t m := by
-    simp only [Finset.mem_image, Prod.exists] at m
+    simp only [Finset.mem_image, Prod.exists] at m 
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
     exact move_right_smaller h
 #align pgame.domineering.state PGame.Domineering.state

b134b2f5

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -159,9 +159,7 @@ def domineering (b : Domineering.Board) : PGame :=
 #align pgame.domineering PGame.domineering
 
 /-- All games of Domineering are short, because each move removes two squares. -/
-instance shortDomineering (b : Domineering.Board) : Short (domineering b) :=
-  by
-  dsimp [domineering]
+instance shortDomineering (b : Domineering.Board) : Short (domineering b) := by dsimp [domineering];
   infer_instance
 #align pgame.short_domineering PGame.shortDomineering
 
@@ -175,16 +173,10 @@ def domineering.l :=
   domineering [(0, 2), (0, 1), (0, 0), (1, 0)].toFinset
 #align pgame.domineering.L PGame.domineering.l
 
-instance shortOne : Short domineering.one :=
-  by
-  dsimp [domineering.one]
-  infer_instance
+instance shortOne : Short domineering.one := by dsimp [domineering.one]; infer_instance
 #align pgame.short_one PGame.shortOne
 
-instance shortL : Short domineering.l :=
-  by
-  dsimp [domineering.L]
-  infer_instance
+instance shortL : Short domineering.l := by dsimp [domineering.L]; infer_instance
 #align pgame.short_L PGame.shortL
 
 -- The VM can play small games successfully:

b134b2f5

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -25,7 +25,7 @@ disjoint parts of the chessboard give sums of games.
 -/
 
 
-namespace Pgame
+namespace PGame
 
 namespace Domineering
 
@@ -35,62 +35,62 @@ open Function
 @[simps]
 def shiftUp : ℤ × ℤ ≃ ℤ × ℤ :=
   (Equiv.refl ℤ).prodCongr (Equiv.addRight (1 : ℤ))
-#align pgame.domineering.shift_up Pgame.Domineering.shiftUp
+#align pgame.domineering.shift_up PGame.Domineering.shiftUp
 
 /-- The equivalence `(x, y) ↦ (x+1, y)`. -/
 @[simps]
 def shiftRight : ℤ × ℤ ≃ ℤ × ℤ :=
   (Equiv.addRight (1 : ℤ)).prodCongr (Equiv.refl ℤ)
-#align pgame.domineering.shift_right Pgame.Domineering.shiftRight
+#align pgame.domineering.shift_right PGame.Domineering.shiftRight
 
 /-- A Domineering board is an arbitrary finite subset of `ℤ × ℤ`. -/
 def Board :=
   Finset (ℤ × ℤ)deriving Inhabited
-#align pgame.domineering.board Pgame.Domineering.Board
+#align pgame.domineering.board PGame.Domineering.Board
 
 attribute [local reducible] board
 
 /-- Left can play anywhere that a square and the square below it are open. -/
 def left (b : Board) : Finset (ℤ × ℤ) :=
   b ∩ b.map shiftUp
-#align pgame.domineering.left Pgame.Domineering.left
+#align pgame.domineering.left PGame.Domineering.left
 
 /-- Right can play anywhere that a square and the square to the left are open. -/
 def right (b : Board) : Finset (ℤ × ℤ) :=
   b ∩ b.map shiftRight
-#align pgame.domineering.right Pgame.Domineering.right
+#align pgame.domineering.right PGame.Domineering.right
 
 theorem mem_left {b : Board} (x : ℤ × ℤ) : x ∈ left b ↔ x ∈ b ∧ (x.1, x.2 - 1) ∈ b :=
   Finset.mem_inter.trans (and_congr Iff.rfl Finset.mem_map_equiv)
-#align pgame.domineering.mem_left Pgame.Domineering.mem_left
+#align pgame.domineering.mem_left PGame.Domineering.mem_left
 
 theorem mem_right {b : Board} (x : ℤ × ℤ) : x ∈ right b ↔ x ∈ b ∧ (x.1 - 1, x.2) ∈ b :=
   Finset.mem_inter.trans (and_congr Iff.rfl Finset.mem_map_equiv)
-#align pgame.domineering.mem_right Pgame.Domineering.mem_right
+#align pgame.domineering.mem_right PGame.Domineering.mem_right
 
 /-- After Left moves, two vertically adjacent squares are removed from the board. -/
 def moveLeft (b : Board) (m : ℤ × ℤ) : Board :=
   (b.eraseₓ m).eraseₓ (m.1, m.2 - 1)
-#align pgame.domineering.move_left Pgame.Domineering.moveLeft
+#align pgame.domineering.move_left PGame.Domineering.moveLeft
 
 /-- After Left moves, two horizontally adjacent squares are removed from the board. -/
 def moveRight (b : Board) (m : ℤ × ℤ) : Board :=
   (b.eraseₓ m).eraseₓ (m.1 - 1, m.2)
-#align pgame.domineering.move_right Pgame.Domineering.moveRight
+#align pgame.domineering.move_right PGame.Domineering.moveRight
 
 theorem fst_pred_mem_erase_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     (m.1 - 1, m.2) ∈ b.eraseₓ m := by
   rw [mem_right] at h
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.fst (pred_ne_self m.1)
-#align pgame.domineering.fst_pred_mem_erase_of_mem_right Pgame.Domineering.fst_pred_mem_erase_of_mem_right
+#align pgame.domineering.fst_pred_mem_erase_of_mem_right PGame.Domineering.fst_pred_mem_erase_of_mem_right
 
 theorem snd_pred_mem_erase_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     (m.1, m.2 - 1) ∈ b.eraseₓ m := by
   rw [mem_left] at h
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.snd (pred_ne_self m.2)
-#align pgame.domineering.snd_pred_mem_erase_of_mem_left Pgame.Domineering.snd_pred_mem_erase_of_mem_left
+#align pgame.domineering.snd_pred_mem_erase_of_mem_left PGame.Domineering.snd_pred_mem_erase_of_mem_left
 
 theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤ Finset.card b :=
   by
@@ -99,7 +99,7 @@ theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤
   have i₁ := Finset.card_erase_lt_of_mem w₁
   have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
   exact Nat.lt_of_le_of_lt i₂ i₁
-#align pgame.domineering.card_of_mem_left Pgame.Domineering.card_of_mem_left
+#align pgame.domineering.card_of_mem_left PGame.Domineering.card_of_mem_left
 
 theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 ≤ Finset.card b :=
   by
@@ -108,7 +108,7 @@ theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 
   have i₁ := Finset.card_erase_lt_of_mem w₁
   have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
   exact Nat.lt_of_le_of_lt i₂ i₁
-#align pgame.domineering.card_of_mem_right Pgame.Domineering.card_of_mem_right
+#align pgame.domineering.card_of_mem_right PGame.Domineering.card_of_mem_right
 
 theorem moveLeft_card {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     Finset.card (moveLeft b m) + 2 = Finset.card b :=
@@ -117,7 +117,7 @@ theorem moveLeft_card {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
   rw [Finset.card_erase_of_mem (snd_pred_mem_erase_of_mem_left h)]
   rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
   exact tsub_add_cancel_of_le (card_of_mem_left h)
-#align pgame.domineering.move_left_card Pgame.Domineering.moveLeft_card
+#align pgame.domineering.move_left_card PGame.Domineering.moveLeft_card
 
 theorem moveRight_card {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     Finset.card (moveRight b m) + 2 = Finset.card b :=
@@ -126,15 +126,15 @@ theorem moveRight_card {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
   rw [Finset.card_erase_of_mem (fst_pred_mem_erase_of_mem_right h)]
   rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
   exact tsub_add_cancel_of_le (card_of_mem_right h)
-#align pgame.domineering.move_right_card Pgame.Domineering.moveRight_card
+#align pgame.domineering.move_right_card PGame.Domineering.moveRight_card
 
 theorem moveLeft_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     Finset.card (moveLeft b m) / 2 < Finset.card b / 2 := by simp [← move_left_card h, lt_add_one]
-#align pgame.domineering.move_left_smaller Pgame.Domineering.moveLeft_smaller
+#align pgame.domineering.move_left_smaller PGame.Domineering.moveLeft_smaller
 
 theorem moveRight_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     Finset.card (moveRight b m) / 2 < Finset.card b / 2 := by simp [← move_right_card h, lt_add_one]
-#align pgame.domineering.move_right_smaller Pgame.Domineering.moveRight_smaller
+#align pgame.domineering.move_right_smaller PGame.Domineering.moveRight_smaller
 
 /-- The instance describing allowed moves on a Domineering board. -/
 instance state : State Board where
@@ -149,43 +149,43 @@ instance state : State Board where
     simp only [Finset.mem_image, Prod.exists] at m
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
     exact move_right_smaller h
-#align pgame.domineering.state Pgame.Domineering.state
+#align pgame.domineering.state PGame.Domineering.state
 
 end Domineering
 
 /-- Construct a pre-game from a Domineering board. -/
-def domineering (b : Domineering.Board) : Pgame :=
-  Pgame.ofState b
-#align pgame.domineering Pgame.domineering
+def domineering (b : Domineering.Board) : PGame :=
+  PGame.ofState b
+#align pgame.domineering PGame.domineering
 
 /-- All games of Domineering are short, because each move removes two squares. -/
 instance shortDomineering (b : Domineering.Board) : Short (domineering b) :=
   by
   dsimp [domineering]
   infer_instance
-#align pgame.short_domineering Pgame.shortDomineering
+#align pgame.short_domineering PGame.shortDomineering
 
 /-- The Domineering board with two squares arranged vertically, in which Left has the only move. -/
 def domineering.one :=
   domineering [(0, 0), (0, 1)].toFinset
-#align pgame.domineering.one Pgame.domineering.one
+#align pgame.domineering.one PGame.domineering.one
 
 /-- The `L` shaped Domineering board, in which Left is exactly half a move ahead. -/
 def domineering.l :=
   domineering [(0, 2), (0, 1), (0, 0), (1, 0)].toFinset
-#align pgame.domineering.L Pgame.domineering.l
+#align pgame.domineering.L PGame.domineering.l
 
 instance shortOne : Short domineering.one :=
   by
   dsimp [domineering.one]
   infer_instance
-#align pgame.short_one Pgame.shortOne
+#align pgame.short_one PGame.shortOne
 
 instance shortL : Short domineering.l :=
   by
   dsimp [domineering.L]
   infer_instance
-#align pgame.short_L Pgame.shortL
+#align pgame.short_L PGame.shortL
 
 -- The VM can play small games successfully:
 -- #eval to_bool (domineering.one ≈ 1)
@@ -214,5 +214,5 @@ instance shortL : Short domineering.l :=
 --   (3,0), (3,1), (3,2), (3,3), (3,4),
 --   (4,0), (4,1), (4,2), (4,3), (4,4)
 --   ].to_finset) ≈ 0)
-end Pgame
+end PGame

b134b2f5

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

b134b2f5

chore: move Game to SetTheory.Game (#6365)

move Game and PGame into namespace SetTheory as _root_.Game might collide with other definitions (e.g. in projects depending on mathlib)

404fef6a

Diff

@@ -21,6 +21,7 @@ Specifically to domineering, we need the fact that
 disjoint parts of the chessboard give sums of games.
 -/
 
+namespace SetTheory
 
 namespace PGame
 
@@ -32,13 +33,13 @@ open Function
 @[simps!]
 def shiftUp : ℤ × ℤ ≃ ℤ × ℤ :=
   (Equiv.refl ℤ).prodCongr (Equiv.addRight (1 : ℤ))
-#align pgame.domineering.shift_up PGame.Domineering.shiftUp
+#align pgame.domineering.shift_up SetTheory.PGame.Domineering.shiftUp
 
 /-- The equivalence `(x, y) ↦ (x+1, y)`. -/
 @[simps!]
 def shiftRight : ℤ × ℤ ≃ ℤ × ℤ :=
   (Equiv.addRight (1 : ℤ)).prodCongr (Equiv.refl ℤ)
-#align pgame.domineering.shift_right PGame.Domineering.shiftRight
+#align pgame.domineering.shift_right SetTheory.PGame.Domineering.shiftRight
 
 /-- A Domineering board is an arbitrary finite subset of `ℤ × ℤ`. -/
 -- Porting note: `reducible` cannot be `local`. For now there are no dependents of this file so
@@ -47,49 +48,49 @@ def shiftRight : ℤ × ℤ ≃ ℤ × ℤ :=
 def Board :=
   Finset (ℤ × ℤ)
 deriving Inhabited
-#align pgame.domineering.board PGame.Domineering.Board
+#align pgame.domineering.board SetTheory.PGame.Domineering.Board
 
 /-- Left can play anywhere that a square and the square below it are open. -/
 def left (b : Board) : Finset (ℤ × ℤ) :=
   b ∩ b.map shiftUp
-#align pgame.domineering.left PGame.Domineering.left
+#align pgame.domineering.left SetTheory.PGame.Domineering.left
 
 /-- Right can play anywhere that a square and the square to the left are open. -/
 def right (b : Board) : Finset (ℤ × ℤ) :=
   b ∩ b.map shiftRight
-#align pgame.domineering.right PGame.Domineering.right
+#align pgame.domineering.right SetTheory.PGame.Domineering.right
 
 theorem mem_left {b : Board} (x : ℤ × ℤ) : x ∈ left b ↔ x ∈ b ∧ (x.1, x.2 - 1) ∈ b :=
   Finset.mem_inter.trans (and_congr Iff.rfl Finset.mem_map_equiv)
-#align pgame.domineering.mem_left PGame.Domineering.mem_left
+#align pgame.domineering.mem_left SetTheory.PGame.Domineering.mem_left
 
 theorem mem_right {b : Board} (x : ℤ × ℤ) : x ∈ right b ↔ x ∈ b ∧ (x.1 - 1, x.2) ∈ b :=
   Finset.mem_inter.trans (and_congr Iff.rfl Finset.mem_map_equiv)
-#align pgame.domineering.mem_right PGame.Domineering.mem_right
+#align pgame.domineering.mem_right SetTheory.PGame.Domineering.mem_right
 
 /-- After Left moves, two vertically adjacent squares are removed from the board. -/
 def moveLeft (b : Board) (m : ℤ × ℤ) : Board :=
   (b.erase m).erase (m.1, m.2 - 1)
-#align pgame.domineering.move_left PGame.Domineering.moveLeft
+#align pgame.domineering.move_left SetTheory.PGame.Domineering.moveLeft
 
 /-- After Left moves, two horizontally adjacent squares are removed from the board. -/
 def moveRight (b : Board) (m : ℤ × ℤ) : Board :=
   (b.erase m).erase (m.1 - 1, m.2)
-#align pgame.domineering.move_right PGame.Domineering.moveRight
+#align pgame.domineering.move_right SetTheory.PGame.Domineering.moveRight
 
 theorem fst_pred_mem_erase_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     (m.1 - 1, m.2) ∈ b.erase m := by
   rw [mem_right] at h
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.fst (pred_ne_self m.1)
-#align pgame.domineering.fst_pred_mem_erase_of_mem_right PGame.Domineering.fst_pred_mem_erase_of_mem_right
+#align pgame.domineering.fst_pred_mem_erase_of_mem_right SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right
 
 theorem snd_pred_mem_erase_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     (m.1, m.2 - 1) ∈ b.erase m := by
   rw [mem_left] at h
   apply Finset.mem_erase_of_ne_of_mem _ h.2
   exact ne_of_apply_ne Prod.snd (pred_ne_self m.2)
-#align pgame.domineering.snd_pred_mem_erase_of_mem_left PGame.Domineering.snd_pred_mem_erase_of_mem_left
+#align pgame.domineering.snd_pred_mem_erase_of_mem_left SetTheory.PGame.Domineering.snd_pred_mem_erase_of_mem_left
 
 theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤ Finset.card b := by
   have w₁ : m ∈ b := (Finset.mem_inter.1 h).1
@@ -97,7 +98,7 @@ theorem card_of_mem_left {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) : 2 ≤
   have i₁ := Finset.card_erase_lt_of_mem w₁
   have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
   exact Nat.lt_of_le_of_lt i₂ i₁
-#align pgame.domineering.card_of_mem_left PGame.Domineering.card_of_mem_left
+#align pgame.domineering.card_of_mem_left SetTheory.PGame.Domineering.card_of_mem_left
 
 theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 ≤ Finset.card b := by
   have w₁ : m ∈ b := (Finset.mem_inter.1 h).1
@@ -105,7 +106,7 @@ theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 
   have i₁ := Finset.card_erase_lt_of_mem w₁
   have i₂ := Nat.lt_of_le_of_lt (Nat.zero_le _) (Finset.card_erase_lt_of_mem w₂)
   exact Nat.lt_of_le_of_lt i₂ i₁
-#align pgame.domineering.card_of_mem_right PGame.Domineering.card_of_mem_right
+#align pgame.domineering.card_of_mem_right SetTheory.PGame.Domineering.card_of_mem_right
 
 theorem moveLeft_card {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     Finset.card (moveLeft b m) + 2 = Finset.card b := by
@@ -113,7 +114,7 @@ theorem moveLeft_card {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
   rw [Finset.card_erase_of_mem (snd_pred_mem_erase_of_mem_left h)]
   rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
   exact tsub_add_cancel_of_le (card_of_mem_left h)
-#align pgame.domineering.move_left_card PGame.Domineering.moveLeft_card
+#align pgame.domineering.move_left_card SetTheory.PGame.Domineering.moveLeft_card
 
 theorem moveRight_card {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     Finset.card (moveRight b m) + 2 = Finset.card b := by
@@ -121,15 +122,15 @@ theorem moveRight_card {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
   rw [Finset.card_erase_of_mem (fst_pred_mem_erase_of_mem_right h)]
   rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
   exact tsub_add_cancel_of_le (card_of_mem_right h)
-#align pgame.domineering.move_right_card PGame.Domineering.moveRight_card
+#align pgame.domineering.move_right_card SetTheory.PGame.Domineering.moveRight_card
 
 theorem moveLeft_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
     Finset.card (moveLeft b m) / 2 < Finset.card b / 2 := by simp [← moveLeft_card h, lt_add_one]
-#align pgame.domineering.move_left_smaller PGame.Domineering.moveLeft_smaller
+#align pgame.domineering.move_left_smaller SetTheory.PGame.Domineering.moveLeft_smaller
 
 theorem moveRight_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) :
     Finset.card (moveRight b m) / 2 < Finset.card b / 2 := by simp [← moveRight_card h, lt_add_one]
-#align pgame.domineering.move_right_smaller PGame.Domineering.moveRight_smaller
+#align pgame.domineering.move_right_smaller SetTheory.PGame.Domineering.moveRight_smaller
 
 /-- The instance describing allowed moves on a Domineering board. -/
 instance state : State Board where
@@ -144,38 +145,38 @@ instance state : State Board where
     simp only [Finset.mem_image, Prod.exists] at m
     rcases m with ⟨_, _, ⟨h, rfl⟩⟩
     exact moveRight_smaller h
-#align pgame.domineering.state PGame.Domineering.state
+#align pgame.domineering.state SetTheory.PGame.Domineering.state
 
 end Domineering
 
 /-- Construct a pre-game from a Domineering board. -/
 def domineering (b : Domineering.Board) : PGame :=
   PGame.ofState b
-#align pgame.domineering PGame.domineering
+#align pgame.domineering SetTheory.PGame.domineering
 
 /-- All games of Domineering are short, because each move removes two squares. -/
 instance shortDomineering (b : Domineering.Board) : Short (domineering b) := by
   dsimp [domineering]
   infer_instance
-#align pgame.short_domineering PGame.shortDomineering
+#align pgame.short_domineering SetTheory.PGame.shortDomineering
 
 /-- The Domineering board with two squares arranged vertically, in which Left has the only move. -/
 def domineering.one :=
   domineering [(0, 0), (0, 1)].toFinset
-#align pgame.domineering.one PGame.domineering.one
+#align pgame.domineering.one SetTheory.PGame.domineering.one
 
 /-- The `L` shaped Domineering board, in which Left is exactly half a move ahead. -/
 def domineering.L :=
   domineering [(0, 2), (0, 1), (0, 0), (1, 0)].toFinset
 set_option linter.uppercaseLean3 false in
-#align pgame.domineering.L PGame.domineering.L
+#align pgame.domineering.L SetTheory.PGame.domineering.L
 
 instance shortOne : Short domineering.one := by dsimp [domineering.one]; infer_instance
-#align pgame.short_one PGame.shortOne
+#align pgame.short_one SetTheory.PGame.shortOne
 
 instance shortL : Short domineering.L := by dsimp [domineering.L]; infer_instance
 set_option linter.uppercaseLean3 false in
-#align pgame.short_L PGame.shortL
+#align pgame.short_L SetTheory.PGame.shortL
 
 -- The VM can play small games successfully:
 -- #eval decide (domineering.one ≈ 1)

b134b2f5

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module set_theory.game.domineering
-! leanprover-community/mathlib commit b134b2f5cf6dd25d4bbfd3c498b6e36c11a17225
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.SetTheory.Game.State
 
+#align_import set_theory.game.domineering from "leanprover-community/mathlib"@"b134b2f5cf6dd25d4bbfd3c498b6e36c11a17225"
+
 /-!
 # Domineering as a combinatorial game.

b134b2f5

feat: port SetTheory.Game.Domineering (#5654)

ad50c210

`set_theory.game.domineering` ⟷ `Mathlib.SetTheory.Game.Domineering`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 358

set_theory.game.domineering ⟷ Mathlib.SetTheory.Game.Domineering

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 358

`set_theory.game.domineering` ⟷ `Mathlib.SetTheory.Game.Domineering`