l3lab/ntp-mathlib huggingface dataset:
theorem 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 

Proof state:
x : PGame
xl' xr' : Type u_1
el : xl' ≃ LeftMoves x
er : xr' ≃ RightMoves x
i : LeftMoves x
⊢ moveLeft (relabel el er) (el.symm i) = moveLeft x i

Next tactic:
simp
theorem 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 

Proof state:
x : PGame
xl' xr' : Type u_1
el : xl' ≃ LeftMoves x
er : xr' ≃ RightMoves x
j : RightMoves x
⊢ moveRight (relabel el er) (er.symm j) = moveRight x j

Next tactic:
simp
/-- The game obtained by relabelling the next moves is a relabelling of the original game. -/
def relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
    x ≡r relabel el er :=
  -- Porting note: needed to add `rfl`
  Relabelling.mk' el er (fun i => by 

Proof state:
x : PGame
xl' xr' : Type ?u.104617
el : xl' ≃ LeftMoves x
er : xr' ≃ RightMoves x
i : LeftMoves (relabel el er)
⊢ moveLeft x (el i) ≡r moveLeft (relabel el er) i

Next tactic:
simp
/-- The game obtained by relabelling the next moves is a relabelling of the original game. -/
def relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
    x ≡r relabel el er :=
  -- Porting note: needed to add `rfl`
  Relabelling.mk' el er (fun i => by simp; 

Proof state:
x : PGame
xl' xr' : Type ?u.104617
el : xl' ≃ LeftMoves x
er : xr' ≃ RightMoves x
i : LeftMoves (relabel el er)
⊢ moveLeft x (el i) ≡r moveLeft x (el i)

Next tactic:
rfl
/-- The game obtained by relabelling the next moves is a relabelling of the original game. -/
def relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
    x ≡r relabel el er :=
  -- Porting note: needed to add `rfl`
  Relabelling.mk' el er (fun i => by simp; rfl) (fun j => by 

Proof state:
x : PGame
xl' xr' : Type ?u.104617
el : xl' ≃ LeftMoves x
er : xr' ≃ RightMoves x
j : RightMoves (relabel el er)
⊢ moveRight x (er j) ≡r moveRight (relabel el er) j

Next tactic:
simp
/-- The game obtained by relabelling the next moves is a relabelling of the original game. -/
def relabelRelabelling {x : PGame} {xl' xr'} (el : xl' ≃ x.LeftMoves) (er : xr' ≃ x.RightMoves) :
    x ≡r relabel el er :=
  -- Porting note: needed to add `rfl`
  Relabelling.mk' el er (fun i => by simp; rfl) (fun j => by simp; 

Proof state:
x : PGame
xl' xr' : Type ?u.104617
el : xl' ≃ LeftMoves x
er : xr' ≃ RightMoves x
j : RightMoves (relabel el er)
⊢ moveRight x (er j) ≡r moveRight x (er j)

Next tactic:
rfl
instance : InvolutiveNeg PGame :=
  { inferInstanceAs (Neg PGame) with
    neg_neg := fun x => by
      

Proof state:
src✝ : Neg PGame := inferInstanceAs (Neg PGame)
x : PGame
⊢ - -x = x

Next tactic:
induction' x with xl xr xL xR ihL ihR
instance : InvolutiveNeg PGame :=
  { inferInstanceAs (Neg PGame) with
    neg_neg := fun x => by
      induction' x with xl xr xL xR ihL ihR
      

Proof state:
case mk
src✝ : Neg PGame := inferInstanceAs (Neg PGame)
xl xr : Type ?u.105626
xL : xl → PGame
xR : xr → PGame
ihL : ∀ (a : xl), - -xL a = xL a
ihR : ∀ (a : xr), - -xR a = xR a
⊢ - -mk xl xr xL xR = mk xl xr xL xR

Next tactic:
simp_rw [neg_def, ihL, ihR]
instance : NegZeroClass PGame :=
  { inferInstanceAs (Zero PGame), inferInstanceAs (Neg PGame) with
    neg_zero := by
      

Proof state:
src✝¹ : Zero PGame := inferInstanceAs (Zero PGame)
src✝ : Neg PGame := inferInstanceAs (Neg PGame)
⊢ -0 = 0

Next tactic:
dsimp [Zero.zero, Neg.neg, neg]
instance : NegZeroClass PGame :=
  { inferInstanceAs (Zero PGame), inferInstanceAs (Neg PGame) with
    neg_zero := by
      dsimp [Zero.zero, Neg.neg, neg]
      

Proof state:
src✝¹ : Zero PGame := inferInstanceAs (Zero PGame)
src✝ : Neg PGame := inferInstanceAs (Neg PGame)
⊢ (mk PEmpty.{?u.106181 + 1} PEmpty.{?u.106181 + 1} (fun i => neg (PEmpty.elim i)) fun i => neg (PEmpty.elim i)) = 0

Next tactic:
congr
instance : NegZeroClass PGame :=
  { inferInstanceAs (Zero PGame), inferInstanceAs (Neg PGame) with
    neg_zero := by
      dsimp [Zero.zero, Neg.neg, neg]
      congr <;> 

Proof state:
case e_a
src✝¹ : Zero PGame := inferInstanceAs (Zero PGame)
src✝ : Neg PGame := inferInstanceAs (Neg PGame)
⊢ (fun i => neg (PEmpty.elim i)) = PEmpty.elim

Next tactic:
funext i
instance : NegZeroClass PGame :=
  { inferInstanceAs (Zero PGame), inferInstanceAs (Neg PGame) with
    neg_zero := by
      dsimp [Zero.zero, Neg.neg, neg]
      congr <;> funext i <;> 

Proof state:
case e_a.h
src✝¹ : Zero PGame := inferInstanceAs (Zero PGame)
src✝ : Neg PGame := inferInstanceAs (Neg PGame)
i : PEmpty.{?u.106181 + 1}
⊢ neg (PEmpty.elim i) = PEmpty.elim i

Next tactic:
cases i
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  

Proof state:
L R : List PGame
⊢ -ofLists L R = ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L)

Next tactic:
set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        rintro rfl
        rfl
      exact this (List.length_map _ _).symm ha
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  

Proof state:
L R : List PGame
⊢ -ofLists L R = ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L)

Next tactic:
simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  

Proof state:
L R : List PGame
⊢ (HEq (fun j => -List.nthLe R ↑j.down (_ : ↑j.down < List.length R)) fun i =>
      -List.nthLe R ↑i.down (_ : ↑i.down < List.length R)) ∧
    HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j =>
      -List.nthLe L ↑j.down (_ : ↑j.down < List.length L)

Next tactic:
constructor
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  

Proof state:
case left
L R : List PGame
⊢ HEq (fun j => -List.nthLe R ↑j.down (_ : ↑j.down < List.length R)) fun i =>
    -List.nthLe R ↑i.down (_ : ↑i.down < List.length R)
case right
L R : List PGame
⊢ HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j =>
    -List.nthLe L ↑j.down (_ : ↑j.down < List.length L)

Next tactic:
all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        rintro rfl
        rfl
      exact this (List.length_map _ _).symm ha
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    

Proof state:
case left
L R : List PGame
⊢ HEq (fun j => -List.nthLe R ↑j.down (_ : ↑j.down < List.length R)) fun i =>
    -List.nthLe R ↑i.down (_ : ↑i.down < List.length R)

Next tactic:
apply hfunext
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · 

Proof state:
case left.hα
L R : List PGame
⊢ ULift.{u_1, 0} (Fin (List.length R)) = ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))

Next tactic:
simp
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · 

Proof state:
case left.h
L R : List PGame
⊢ ∀ (a : ULift.{u_1, 0} (Fin (List.length R))) (a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))),
    HEq a a' →
      HEq (-List.nthLe R ↑a.down (_ : ↑a.down < List.length R)) (-List.nthLe R ↑a'.down (_ : ↑a'.down < List.length R))

Next tactic:
intro a a' ha
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      

Proof state:
case left.h
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length R))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))
ha : HEq a a'
⊢ HEq (-List.nthLe R ↑a.down (_ : ↑a.down < List.length R)) (-List.nthLe R ↑a'.down (_ : ↑a'.down < List.length R))

Next tactic:
congr 2
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      

Proof state:
case left.h.h.e_a.e_n
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length R))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))
ha : HEq a a'
⊢ ↑a.down = ↑a'.down

Next tactic:
have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        rintro rfl
        rfl
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        

Proof state:
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length R))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))
ha : HEq a a'
⊢ ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.107591, 0} (Fin m)} {c : ULift.{?u.107591, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down

Next tactic:
rintro m n rfl b c
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        

Proof state:
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length R))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))
ha : HEq a a'
m : ℕ
b c : ULift.{?u.107591, 0} (Fin m)
⊢ HEq b c → ↑b.down = ↑c.down

Next tactic:
simp only [heq_eq_eq]
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        

Proof state:
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length R))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))
ha : HEq a a'
m : ℕ
b c : ULift.{?u.107591, 0} (Fin m)
⊢ b = c → ↑b.down = ↑c.down

Next tactic:
rintro rfl
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        rintro rfl
        

Proof state:
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length R))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))
ha : HEq a a'
m : ℕ
b : ULift.{?u.107591, 0} (Fin m)
⊢ ↑b.down = ↑b.down

Next tactic:
rfl
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        rintro rfl
        rfl
      

Proof state:
case left.h.h.e_a.e_n
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length R))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) R)))
ha : HEq a a'
this :
  ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.107591, 0} (Fin m)} {c : ULift.{?u.107591, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ ↑a.down = ↑a'.down

Next tactic:
exact this (List.length_map _ _).symm ha
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    

Proof state:
case right
L R : List PGame
⊢ HEq (fun i => -List.nthLe L ↑i.down (_ : ↑i.down < List.length L)) fun j =>
    -List.nthLe L ↑j.down (_ : ↑j.down < List.length L)

Next tactic:
apply hfunext
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · 

Proof state:
case right.hα
L R : List PGame
⊢ ULift.{u_1, 0} (Fin (List.length L)) = ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))

Next tactic:
simp
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · 

Proof state:
case right.h
L R : List PGame
⊢ ∀ (a : ULift.{u_1, 0} (Fin (List.length L))) (a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))),
    HEq a a' →
      HEq (-List.nthLe L ↑a.down (_ : ↑a.down < List.length L)) (-List.nthLe L ↑a'.down (_ : ↑a'.down < List.length L))

Next tactic:
intro a a' ha
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      

Proof state:
case right.h
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length L))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
⊢ HEq (-List.nthLe L ↑a.down (_ : ↑a.down < List.length L)) (-List.nthLe L ↑a'.down (_ : ↑a'.down < List.length L))

Next tactic:
congr 2
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      

Proof state:
case right.h.h.e_a.e_n
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length L))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
⊢ ↑a.down = ↑a'.down

Next tactic:
have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        rintro rfl
        rfl
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        

Proof state:
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length L))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
⊢ ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.108206, 0} (Fin m)} {c : ULift.{?u.108206, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down

Next tactic:
rintro m n rfl b c
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        

Proof state:
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length L))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
m : ℕ
b c : ULift.{?u.108206, 0} (Fin m)
⊢ HEq b c → ↑b.down = ↑c.down

Next tactic:
simp only [heq_eq_eq]
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        

Proof state:
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length L))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
m : ℕ
b c : ULift.{?u.108206, 0} (Fin m)
⊢ b = c → ↑b.down = ↑c.down

Next tactic:
rintro rfl
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        rintro rfl
        

Proof state:
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length L))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
m : ℕ
b : ULift.{?u.108206, 0} (Fin m)
⊢ ↑b.down = ↑b.down

Next tactic:
rfl
@[simp]
theorem neg_ofLists (L R : List PGame) :
    -ofLists L R = ofLists (R.map fun x => -x) (L.map fun x => -x) := by
  set_option linter.deprecated false in
  simp only [ofLists, neg_def, List.length_map, List.nthLe_map', eq_self_iff_true, true_and,
    mk.injEq]
  constructor
  all_goals
    apply hfunext
    · simp
    · intro a a' ha
      congr 2
      have :
        ∀ {m n} (_ : m = n) {b : ULift (Fin m)} {c : ULift (Fin n)} (_ : HEq b c),
          (b.down : ℕ) = ↑c.down := by
        rintro m n rfl b c
        simp only [heq_eq_eq]
        rintro rfl
        rfl
      

Proof state:
case right.h.h.e_a.e_n
L R : List PGame
a : ULift.{u_1, 0} (Fin (List.length L))
a' : ULift.{u_1, 0} (Fin (List.length (List.map (fun x => -x) L)))
ha : HEq a a'
this :
  ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.108206, 0} (Fin m)} {c : ULift.{?u.108206, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ ↑a.down = ↑a'.down

Next tactic:
exact this (List.length_map _ _).symm ha
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  

Proof state:
x y : PGame
⊢ IsOption x (-y) ↔ IsOption (-x) y

Next tactic:
rw [IsOption_iff, IsOption_iff, or_comm]
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  rw [IsOption_iff, IsOption_iff, or_comm]
  

Proof state:
x y : PGame
⊢ ((∃ i, x = moveRight (-y) i) ∨ ∃ i, x = moveLeft (-y) i) ↔ (∃ i, -x = moveLeft y i) ∨ ∃ i, -x = moveRight y i

Next tactic:
cases y
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  rw [IsOption_iff, IsOption_iff, or_comm]
  cases y;
  

Proof state:
case mk
x : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ ((∃ i, x = moveRight (-mk α✝ β✝ a✝¹ a✝) i) ∨ ∃ i, x = moveLeft (-mk α✝ β✝ a✝¹ a✝) i) ↔
    (∃ i, -x = moveLeft (mk α✝ β✝ a✝¹ a✝) i) ∨ ∃ i, -x = moveRight (mk α✝ β✝ a✝¹ a✝) i

Next tactic:
apply or_congr
theorem isOption_neg {x y : PGame} : IsOption x (-y) ↔ IsOption (-x) y := by
  rw [IsOption_iff, IsOption_iff, or_comm]
  cases y;
  apply or_congr <;>
    · 

Proof state:
case mk.h₁
x : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (∃ i, x = moveRight (-mk α✝ β✝ a✝¹ a✝) i) ↔ ∃ i, -x = moveLeft (mk α✝ β✝ a✝¹ a✝) i

Next tactic:
apply exists_congr
theorem 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
      

Proof state:
case mk.h₁.h
x : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ ∀ (a : RightMoves (-mk α✝ β✝ a✝¹ a✝)), x = moveRight (-mk α✝ β✝ a✝¹ a✝) a ↔ -x = moveLeft (mk α✝ β✝ a✝¹ a✝) a

Next tactic:
intro
theorem 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
      

Proof state:
case mk.h₁.h
x : PGame
α✝ β✝ : Type u_1
a✝² : α✝ → PGame
a✝¹ : β✝ → PGame
a✝ : RightMoves (-mk α✝ β✝ a✝² a✝¹)
⊢ x = moveRight (-mk α✝ β✝ a✝² a✝¹) a✝ ↔ -x = moveLeft (mk α✝ β✝ a✝² a✝¹) a✝

Next tactic:
rw [neg_eq_iff_eq_neg]