Theorem: SetTheory.PGame.neg_ofLists
File: Mathlib/SetTheory/Game/PGame.lean

tactic: simp only [ofLists, neg_def, List.getElem_map, mk.injEq, List.length_map, true_and]
state_before: xl xr : Type u
L R : List PGame
⊢ -ofLists L R = ofLists (List.map (fun x => -x) R) (List.map (fun x => -x) L)
state_after: xl xr : Type u
L R : List PGame
⊢ (HEq (fun j => -R[↑j.down]) fun i => -R[↑i.down]) ∧ HEq (fun i => -L[↑i.down]) fun j => -L[↑j.down]

tactic: constructor
state_before: xl xr : Type u
L R : List PGame
⊢ (HEq (fun j => -R[↑j.down]) fun i => -R[↑i.down]) ∧ HEq (fun i => -L[↑i.down]) fun j => -L[↑j.down]
state_after: case left
xl xr : Type u
L R : List PGame
⊢ HEq (fun j => -R[↑j.down]) fun i => -R[↑i.down]

case right
xl xr : Type u
L R : List PGame
⊢ HEq (fun i => -L[↑i.down]) fun j => -L[↑j.down]

tactic: apply hfunext
state_before: case right
xl xr : Type u
L R : List PGame
⊢ HEq (fun i => -L[↑i.down]) fun j => -L[↑j.down]
state_after: case right.hα
xl xr : Type u
L R : List PGame
⊢ ULift.{u_1, 0} (Fin L.length) = ULift.{u_1, 0} (Fin (List.map (fun x => -x) L).length)

case right.h
xl xr : Type u
L R : List PGame
⊢ ∀ (a : ULift.{u_1, 0} (Fin L.length)) (a' : ULift.{u_1, 0} (Fin (List.map (fun x => -x) L).length)),
    HEq a a' → HEq (-L[↑a.down]) (-L[↑a'.down])

tactic: simp
state_before: case right.hα
xl xr : Type u
L R : List PGame
⊢ ULift.{u_1, 0} (Fin L.length) = ULift.{u_1, 0} (Fin (List.map (fun x => -x) L).length)
state_after: no goals

tactic: rintro ⟨⟨a, ha⟩⟩ ⟨⟨b, hb⟩⟩ h
state_before: case right.h
xl xr : Type u
L R : List PGame
⊢ ∀ (a : ULift.{u_1, 0} (Fin L.length)) (a' : ULift.{u_1, 0} (Fin (List.map (fun x => -x) L).length)),
    HEq a a' → HEq (-L[↑a.down]) (-L[↑a'.down])
state_after: case right.h.up.mk.up.mk
xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
⊢ HEq (-L[↑{ down := ⟨a, ha⟩ }.down]) (-L[↑{ down := ⟨b, hb⟩ }.down])

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
state_before: case right.h.up.mk.up.mk
xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
⊢ HEq (-L[↑{ down := ⟨a, ha⟩ }.down]) (-L[↑{ down := ⟨b, hb⟩ }.down])
state_after: case right.h.up.mk.up.mk
xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
this :
  ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.87735, 0} (Fin m)} {c : ULift.{?u.87735, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ HEq (-L[↑{ down := ⟨a, ha⟩ }.down]) (-L[↑{ down := ⟨b, hb⟩ }.down])

tactic: simp only [heq_eq_eq]
state_before: case right.h.up.mk.up.mk
xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
this :
  ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.87735, 0} (Fin m)} {c : ULift.{?u.87735, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ HEq (-L[↑{ down := ⟨a, ha⟩ }.down]) (-L[↑{ down := ⟨b, hb⟩ }.down])
state_after: case right.h.up.mk.up.mk
xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
this :
  ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.87735, 0} (Fin m)} {c : ULift.{?u.87735, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ -L[a] = -L[b]

tactic: congr 5
state_before: case right.h.up.mk.up.mk
xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
this :
  ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.87735, 0} (Fin m)} {c : ULift.{?u.87735, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ -L[a] = -L[b]
state_after: case right.h.up.mk.up.mk.e_a.e_i
xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
this :
  ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.87735, 0} (Fin m)} {c : ULift.{?u.87735, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ a = b

tactic: exact this (List.length_map _ _).symm h
state_before: case right.h.up.mk.up.mk.e_a.e_i
xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
this :
  ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.87735, 0} (Fin m)} {c : ULift.{?u.87735, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
⊢ a = b
state_after: no goals

tactic: rintro m n rfl b c
state_before: xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b : ℕ
hb : b < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b, hb⟩ }
⊢ ∀ {m n : ℕ},
    m = n → ∀ {b : ULift.{?u.87735, 0} (Fin m)} {c : ULift.{?u.87735, 0} (Fin n)}, HEq b c → ↑b.down = ↑c.down
state_after: xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b✝ : ℕ
hb : b✝ < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b✝, hb⟩ }
m : ℕ
b c : ULift.{?u.87735, 0} (Fin m)
⊢ HEq b c → ↑b.down = ↑c.down

tactic: simp only [heq_eq_eq]
state_before: xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b✝ : ℕ
hb : b✝ < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b✝, hb⟩ }
m : ℕ
b c : ULift.{?u.87735, 0} (Fin m)
⊢ HEq b c → ↑b.down = ↑c.down
state_after: xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b✝ : ℕ
hb : b✝ < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b✝, hb⟩ }
m : ℕ
b c : ULift.{?u.87735, 0} (Fin m)
⊢ b = c → ↑b.down = ↑c.down

tactic: rintro rfl
state_before: xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b✝ : ℕ
hb : b✝ < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b✝, hb⟩ }
m : ℕ
b c : ULift.{?u.87735, 0} (Fin m)
⊢ b = c → ↑b.down = ↑c.down
state_after: xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b✝ : ℕ
hb : b✝ < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b✝, hb⟩ }
m : ℕ
b : ULift.{?u.87735, 0} (Fin m)
⊢ ↑b.down = ↑b.down

tactic: rfl
state_before: xl xr : Type u
L R : List PGame
a : ℕ
ha : a < L.length
b✝ : ℕ
hb : b✝ < (List.map (fun x => -x) L).length
h : HEq { down := ⟨a, ha⟩ } { down := ⟨b✝, hb⟩ }
m : ℕ
b : ULift.{?u.87735, 0} (Fin m)
⊢ ↑b.down = ↑b.down
state_after: no goals