formal
stringlengths 41
427k
| informal
stringclasses 1
value |
|---|---|
SetTheory.PGame.nim_add_equiv_zero_iff ** o₁ o₂ : Ordinal.{u_1} ⊢ nim o₁ + nim o₂ ≈ 0 ↔ o₁ = o₂ ** constructor ** case mp o₁ o₂ : Ordinal.{u_1} ⊢ nim o₁ + nim o₂ ≈ 0 → o₁ = o₂ ** refine' not_imp_not.1 fun hne : _ ≠ _ => (Impartial.not_equiv_zero_iff (nim o₁ + nim o₂)).2 _ ** case mp o₁ o₂ : Ordinal.{u_1} hne : o₁ ≠ o₂ ⊢ nim o₁ + nim o₂ ‖ 0 ** wlog h : o₁ < o₂ ** o₁ o₂ : Ordinal.{u_1} hne : o₁ ≠ o₂ h : o₁ < o₂ ⊢ nim o₁ + nim o₂ ‖ 0 ** rw [Impartial.fuzzy_zero_iff_gf, zero_lf_le, nim_def o₂] ** o₁ o₂ : Ordinal.{u_1} hne : o₁ ≠ o₂ h : o₁ < o₂ ⊢ ∃ i, 0 ≤ moveLeft (nim o₁ + mk (Quotient.out o₂).α (Quotient.out o₂).α (fun o₂_1 => nim (typein (fun x x_1 => x < x_1) o₂_1)) fun o₂_1 => nim (typein (fun x x_1 => x < x_1) o₂_1)) i ** refine' ⟨toLeftMovesAdd (Sum.inr _), _⟩ ** case mp.inr o₁ o₂ : Ordinal.{u_1} hne : o₁ ≠ o₂ this : ∀ (o₁ o₂ : Ordinal.{u_1}), o₁ ≠ o₂ → o₁ < o₂ → nim o₁ + nim o₂ ‖ 0 h : ¬o₁ < o₂ ⊢ nim o₁ + nim o₂ ‖ 0 ** exact (fuzzy_congr_left add_comm_equiv).1 (this _ _ hne.symm (hne.lt_or_lt.resolve_left h)) ** case refine'_1 o₁ o₂ : Ordinal.{u_1} hne : o₁ ≠ o₂ h : o₁ < o₂ ⊢ LeftMoves (mk (Quotient.out o₂).α (Quotient.out o₂).α (fun o₂_1 => nim (typein (fun x x_1 => x < x_1) o₂_1)) fun o₂_1 => nim (typein (fun x x_1 => x < x_1) o₂_1)) ** exact (Ordinal.principalSegOut h).top ** case refine'_2 o₁ o₂ : Ordinal.{u_1} hne : o₁ ≠ o₂ h : o₁ < o₂ ⊢ 0 ≤ moveLeft (nim o₁ + mk (Quotient.out o₂).α (Quotient.out o₂).α (fun o₂_1 => nim (typein (fun x x_1 => x < x_1) o₂_1)) fun o₂_1 => nim (typein (fun x x_1 => x < x_1) o₂_1)) (↑toLeftMovesAdd (Sum.inr (principalSegOut h).top)) ** simpa only [Ordinal.typein_top, Ordinal.type_lt, PGame.add_moveLeft_inr, PGame.moveLeft_mk]
using (Impartial.add_self (nim o₁)).2 ** case mpr o₁ o₂ : Ordinal.{u_1} ⊢ o₁ = o₂ → nim o₁ + nim o₂ ≈ 0 ** rintro rfl ** case mpr o₁ : Ordinal.{u_1} ⊢ nim o₁ + nim o₁ ≈ 0 ** exact Impartial.add_self (nim o₁) ** Qed
| |
SetTheory.PGame.nim_add_fuzzy_zero_iff ** o₁ o₂ : Ordinal.{u_1} ⊢ nim o₁ + nim o₂ ‖ 0 ↔ o₁ ≠ o₂ ** rw [iff_not_comm, Impartial.not_fuzzy_zero_iff, nim_add_equiv_zero_iff] ** Qed
| |
SetTheory.PGame.nim_equiv_iff_eq ** o₁ o₂ : Ordinal.{u_1} ⊢ nim o₁ ≈ nim o₂ ↔ o₁ = o₂ ** rw [Impartial.equiv_iff_add_equiv_zero, nim_add_equiv_zero_iff] ** Qed
| |
SetTheory.PGame.grundyValue_eq_mex_left ** G : PGame ⊢ grundyValue G = mex fun i => grundyValue (moveLeft G i) ** rw [grundyValue] ** Qed
| |
SetTheory.PGame.equiv_nim_grundyValue ** x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ ⊢ x✝ ≈ nim (grundyValue x✝) ** rw [Impartial.equiv_iff_add_equiv_zero, ← Impartial.forall_leftMoves_fuzzy_iff_equiv_zero] ** x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ ⊢ ∀ (i : LeftMoves (x✝ + nim (grundyValue x✝))), moveLeft (x✝ + nim (grundyValue x✝)) i ‖ 0 ** intro i ** x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) ⊢ moveLeft (x✝ + nim (grundyValue x✝)) i ‖ 0 ** apply leftMoves_add_cases i ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) ⊢ ∀ (i : LeftMoves x✝), moveLeft (x✝ + nim (grundyValue x✝)) (↑toLeftMovesAdd (Sum.inl i)) ‖ 0 ** intro i₁ ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₁ : LeftMoves x✝ ⊢ moveLeft (x✝ + nim (grundyValue x✝)) (↑toLeftMovesAdd (Sum.inl i₁)) ‖ 0 ** rw [add_moveLeft_inl] ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₁ : LeftMoves x✝ ⊢ moveLeft x✝ i₁ + nim (grundyValue x✝) ‖ 0 ** apply
(fuzzy_congr_left (add_congr_left (Equiv.symm (equiv_nim_grundyValue (G.moveLeft i₁))))).1 ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₁ : LeftMoves x✝ ⊢ nim (grundyValue (moveLeft G i₁)) + nim (grundyValue x✝) ‖ 0 ** rw [nim_add_fuzzy_zero_iff] ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₁ : LeftMoves x✝ ⊢ grundyValue (moveLeft G i₁) ≠ grundyValue x✝ ** intro heq ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₁ : LeftMoves x✝ heq : grundyValue (moveLeft G i₁) = grundyValue x✝ ⊢ False ** rw [eq_comm, grundyValue_eq_mex_left G] at heq ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₁ : LeftMoves x✝ heq : (mex fun i => grundyValue (moveLeft G i)) = grundyValue (moveLeft G i₁) ⊢ False ** have h := Ordinal.ne_mex.{u, u} (fun i ↦ grundyValue (moveLeft G i)) ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₁ : LeftMoves x✝ heq : (mex fun i => grundyValue (moveLeft G i)) = grundyValue (moveLeft G i₁) h : ∀ (i : LeftMoves G), grundyValue (moveLeft G i) ≠ mex fun i => grundyValue (moveLeft G i) ⊢ False ** rw [heq] at h ** case hl x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₁ : LeftMoves x✝ heq : (mex fun i => grundyValue (moveLeft G i)) = grundyValue (moveLeft G i₁) h : ∀ (i : LeftMoves G), grundyValue (moveLeft G i) ≠ grundyValue (moveLeft G i₁) ⊢ False ** exact (h i₁).irrefl ** case hr x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) ⊢ ∀ (i : LeftMoves (nim (grundyValue x✝))), moveLeft (x✝ + nim (grundyValue x✝)) (↑toLeftMovesAdd (Sum.inr i)) ‖ 0 ** intro i₂ ** case hr x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (nim (grundyValue x✝)) ⊢ moveLeft (x✝ + nim (grundyValue x✝)) (↑toLeftMovesAdd (Sum.inr i₂)) ‖ 0 ** rw [add_moveLeft_inr, ← Impartial.exists_left_move_equiv_iff_fuzzy_zero] ** case hr x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (nim (grundyValue x✝)) ⊢ ∃ i, moveLeft (x✝ + moveLeft (nim (grundyValue x✝)) i₂) i ≈ 0 ** revert i₂ ** case hr x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) ⊢ ∀ (i₂ : LeftMoves (nim (grundyValue x✝))), ∃ i, moveLeft (x✝ + moveLeft (nim (grundyValue x✝)) i₂) i ≈ 0 ** rw [nim_def] ** case hr x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) ⊢ ∀ (i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂))), ∃ i, moveLeft (x✝ + moveLeft (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i₂) i ≈ 0 ** intro i₂ ** case hr x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) ⊢ ∃ i, moveLeft (x✝ + moveLeft (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i₂) i ≈ 0 ** have h' :
∃ i : G.LeftMoves,
grundyValue (G.moveLeft i) = Ordinal.typein (Quotient.out (grundyValue G)).r i₂ := by
revert i₂
rw [grundyValue_eq_mex_left]
intro i₂
have hnotin : _ ∉ _ := fun hin =>
(le_not_le_of_lt (Ordinal.typein_lt_self i₂)).2 (csInf_le' hin)
simpa using hnotin ** case hr x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) h' : ∃ i, grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ ⊢ ∃ i, moveLeft (x✝ + moveLeft (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i₂) i ≈ 0 ** cases' h' with i hi ** case hr.intro x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i✝ : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i : LeftMoves G hi : grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ ⊢ ∃ i, moveLeft (x✝ + moveLeft (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i₂) i ≈ 0 ** use toLeftMovesAdd (Sum.inl i) ** case h x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i✝ : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i : LeftMoves G hi : grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ ⊢ moveLeft (x✝ + moveLeft (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i₂) (↑toLeftMovesAdd (Sum.inl i)) ≈ 0 ** rw [add_moveLeft_inl, moveLeft_mk] ** case h x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i✝ : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i : LeftMoves G hi : grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ ⊢ moveLeft x✝ i + nim (typein (fun x x_1 => x < x_1) i₂) ≈ 0 ** apply Equiv.trans (add_congr_left (equiv_nim_grundyValue (G.moveLeft i))) ** case h x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i✝ : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) i : LeftMoves G hi : grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ ⊢ nim (grundyValue (moveLeft G i)) + nim (typein (fun x x_1 => x < x_1) i₂) ≈ 0 ** simpa only [hi] using Impartial.add_self (nim (grundyValue (G.moveLeft i))) ** x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) ⊢ ∃ i, grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ ** revert i₂ ** x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) ⊢ ∀ (i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂))), ∃ i, grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ ** rw [grundyValue_eq_mex_left] ** x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) ⊢ ∀ (i₂ : LeftMoves (mk (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).α (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂))), ∃ i, grundyValue (moveLeft G i) = typein (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).r i₂ ** intro i₂ ** x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).α (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) ⊢ ∃ i, grundyValue (moveLeft G i) = typein (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).r i₂ ** have hnotin : _ ∉ _ := fun hin =>
(le_not_le_of_lt (Ordinal.typein_lt_self i₂)).2 (csInf_le' hin) ** x✝ : PGame inst✝ : Impartial x✝ G : PGame := x✝ i : LeftMoves (x✝ + nim (grundyValue x✝)) i₂ : LeftMoves (mk (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).α (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) hnotin : ¬typein (fun x x_1 => x < x_1) i₂ ∈ (Set.range fun i => grundyValue (moveLeft x✝ i))ᶜ ⊢ ∃ i, grundyValue (moveLeft G i) = typein (Quotient.out (mex fun i => grundyValue (moveLeft x✝ i))).r i₂ ** simpa using hnotin ** x✝ : PGame inst✝ : Impartial x✝ a✝ : ∀ (y : (x : PGame) ×' Impartial x), (invImage (fun a => PSigma.casesOn a fun G snd => G) instWellFoundedRelationPGame).1 y { fst := x✝, snd := inst✝ } → y.1 ≈ nim (grundyValue y.1) G : PGame := x✝ i₂ : LeftMoves (mk (Quotient.out (grundyValue x✝)).α (Quotient.out (grundyValue x✝)).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) h' : ∃ i, grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ i : LeftMoves G hi : grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂ h✝ : h' = (_ : ∃ i, grundyValue (moveLeft G i) = typein (Quotient.out (grundyValue G)).r i₂) ⊢ (invImage (fun a => PSigma.casesOn a fun G snd => G) instWellFoundedRelationPGame).1 { fst := moveLeft G i, snd := (_ : Impartial (moveLeft G i)) } { fst := x✝, snd := inst✝ } ** pgame_wf_tac ** Qed
| |
SetTheory.PGame.grundyValue_eq_iff_equiv_nim ** G : PGame inst✝ : Impartial G o : Ordinal.{u_1} ⊢ grundyValue G = o → G ≈ nim o ** rintro rfl ** G : PGame inst✝ : Impartial G ⊢ G ≈ nim (grundyValue G) ** exact equiv_nim_grundyValue G ** G : PGame inst✝ : Impartial G o : Ordinal.{u_1} ⊢ G ≈ nim o → grundyValue G = o ** intro h ** G : PGame inst✝ : Impartial G o : Ordinal.{u_1} h : G ≈ nim o ⊢ grundyValue G = o ** rw [← nim_equiv_iff_eq] ** G : PGame inst✝ : Impartial G o : Ordinal.{u_1} h : G ≈ nim o ⊢ nim (grundyValue G) ≈ nim o ** exact Equiv.trans (Equiv.symm (equiv_nim_grundyValue G)) h ** Qed
| |
SetTheory.PGame.grundyValue_iff_equiv_zero ** G : PGame inst✝ : Impartial G ⊢ grundyValue G = 0 ↔ G ≈ 0 ** rw [← grundyValue_eq_iff_equiv, grundyValue_zero] ** Qed
| |
SetTheory.PGame.grundyValue_neg ** G : PGame inst✝ : Impartial G ⊢ grundyValue (-G) = grundyValue G ** rw [grundyValue_eq_iff_equiv_nim, neg_equiv_iff, neg_nim, ← grundyValue_eq_iff_equiv_nim] ** Qed
| |
SetTheory.PGame.grundyValue_eq_mex_right ** l r : Type u L : l → PGame R : r → PGame x✝ : Impartial (mk l r L R) ⊢ grundyValue (mk l r L R) = mex fun i => grundyValue (moveRight (mk l r L R) i) ** rw [← grundyValue_neg, grundyValue_eq_mex_left] ** l r : Type u L : l → PGame R : r → PGame x✝ : Impartial (mk l r L R) ⊢ (mex fun i => grundyValue (moveLeft (-mk l r L R) i)) = mex fun i => grundyValue (moveRight (mk l r L R) i) ** congr ** case e_f l r : Type u L : l → PGame R : r → PGame x✝ : Impartial (mk l r L R) ⊢ (fun i => grundyValue (moveLeft (-mk l r L R) i)) = fun i => grundyValue (moveRight (mk l r L R) i) ** ext i ** case e_f.h l r : Type u L : l → PGame R : r → PGame x✝ : Impartial (mk l r L R) i : LeftMoves (-mk l r L R) ⊢ grundyValue (moveLeft (-mk l r L R) i) = grundyValue (moveRight (mk l r L R) i) ** haveI : (R i).Impartial := @Impartial.moveRight_impartial ⟨l, r, L, R⟩ _ i ** case e_f.h l r : Type u L : l → PGame R : r → PGame x✝ : Impartial (mk l r L R) i : LeftMoves (-mk l r L R) this : Impartial (R i) ⊢ grundyValue (moveLeft (-mk l r L R) i) = grundyValue (moveRight (mk l r L R) i) ** apply grundyValue_neg ** Qed
| |
SetTheory.PGame.grundyValue_nim_add_nim ** n m : ℕ ⊢ grundyValue (nim ↑n + nim ↑m) = ↑(n ^^^ m) ** induction' n using Nat.strong_induction_on with n hn generalizing m ** case h m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ ⊢ grundyValue (nim ↑n + nim ↑m) = ↑(n ^^^ m) ** induction' m using Nat.strong_induction_on with m hm ** case h.h m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) ⊢ grundyValue (nim ↑n + nim ↑m) = ↑(n ^^^ m) ** rw [grundyValue_eq_mex_left] ** case h.h m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) ⊢ (mex fun i => grundyValue (moveLeft (nim ↑n + nim ↑m) i)) = ↑(n ^^^ m) ** refine (Ordinal.mex_le_of_ne.{u, u} fun i => ?_).antisymm
(Ordinal.le_mex_of_forall fun ou hu => ?_) ** case h.h.refine_1.hr m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) ⊢ ∀ (i : LeftMoves (nim ↑m)), grundyValue (moveLeft (nim ↑n + nim ↑m) (↑toLeftMovesAdd (Sum.inr i))) ≠ ↑(n ^^^ m) ** refine' fun a => leftMovesNimRecOn a fun ok hk => _ ** case h.h.refine_1.hr m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) ok : Ordinal.{u} hk : ok < ↑m ⊢ grundyValue (moveLeft (nim ↑n + nim ↑m) (↑toLeftMovesAdd (Sum.inr (↑toLeftMovesNim { val := ok, property := hk })))) ≠ ↑(n ^^^ m) ** obtain ⟨k, rfl⟩ := Ordinal.lt_omega.1 (hk.trans (Ordinal.nat_lt_omega _)) ** case h.h.refine_1.hr.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) k : ℕ hk : ↑k < ↑m ⊢ grundyValue (moveLeft (nim ↑n + nim ↑m) (↑toLeftMovesAdd (Sum.inr (↑toLeftMovesNim { val := ↑k, property := hk })))) ≠ ↑(n ^^^ m) ** simp only [add_moveLeft_inl, add_moveLeft_inr, moveLeft_nim', Equiv.symm_apply_apply] ** case h.h.refine_1.hr.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) k : ℕ hk : ↑k < ↑m ⊢ grundyValue (nim ↑n + nim ↑k) ≠ ↑(n ^^^ m) ** rw [nat_cast_lt] at hk ** case h.h.refine_1.hr.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) k : ℕ hk : k < m ⊢ grundyValue (nim ↑n + nim ↑k) ≠ ↑(n ^^^ m) ** first
| rw [hn _ hk]
| rw [hm _ hk] ** case h.h.refine_1.hr.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) k : ℕ hk : k < m ⊢ ↑(n ^^^ k) ≠ ↑(n ^^^ m) ** refine' fun h => hk.ne _ ** case h.h.refine_1.hr.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) k : ℕ hk : k < m h : ↑(n ^^^ k) = ↑(n ^^^ m) ⊢ k = m ** rw [Ordinal.nat_cast_inj] at h ** case h.h.refine_1.hr.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) k : ℕ hk : k < m h : n ^^^ k = n ^^^ m ⊢ k = m ** first
| rwa [Nat.xor_left_inj] at h
| rwa [Nat.xor_right_inj] at h ** case h.h.refine_1.hl.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑n) k : ℕ hk : k < n ⊢ grundyValue (nim ↑k + nim ↑m) ≠ ↑(n ^^^ m) ** rw [hn _ hk] ** case h.h.refine_1.hr.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) k : ℕ hk : k < m ⊢ grundyValue (nim ↑n + nim ↑k) ≠ ↑(n ^^^ m) ** rw [hm _ hk] ** case h.h.refine_1.hl.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑n) k : ℕ hk : k < n h : k ^^^ m = n ^^^ m ⊢ k = n ** rwa [Nat.xor_left_inj] at h ** case h.h.refine_1.hr.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) i : LeftMoves (nim ↑n + nim ↑m) a : LeftMoves (nim ↑m) k : ℕ hk : k < m h : n ^^^ k = n ^^^ m ⊢ k = m ** rwa [Nat.xor_right_inj] at h ** case h.h.refine_2 m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) ou : Ordinal.{u} hu : ou < ↑(n ^^^ m) ⊢ ∃ i, grundyValue (moveLeft (nim ↑n + nim ↑m) i) = ou ** obtain ⟨u, rfl⟩ := Ordinal.lt_omega.1 (hu.trans (Ordinal.nat_lt_omega _)) ** case h.h.refine_2.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : ↑u < ↑(n ^^^ m) ⊢ ∃ i, grundyValue (moveLeft (nim ↑n + nim ↑m) i) = ↑u ** replace hu := Ordinal.nat_cast_lt.1 hu ** case h.h.refine_2.intro m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : u < n ^^^ m ⊢ ∃ i, grundyValue (moveLeft (nim ↑n + nim ↑m) i) = ↑u ** cases' Nat.lt_xor_cases hu with h h ** case h.h.refine_2.intro.inl m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : u < n ^^^ m h : u ^^^ m < n ⊢ ∃ i, grundyValue (moveLeft (nim ↑n + nim ↑m) i) = ↑u ** refine' ⟨toLeftMovesAdd (Sum.inl <| toLeftMovesNim ⟨_, Ordinal.nat_cast_lt.2 h⟩), _⟩ ** case h.h.refine_2.intro.inl m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : u < n ^^^ m h : u ^^^ m < n ⊢ grundyValue (moveLeft (nim ↑n + nim ↑m) (↑toLeftMovesAdd (Sum.inl (↑toLeftMovesNim { val := ↑(u ^^^ m), property := (_ : ↑(u ^^^ m) < ↑n) })))) = ↑u ** simp [Nat.lxor_cancel_right, hn _ h] ** case h.h.refine_2.intro.inr m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : u < n ^^^ m h : u ^^^ n < m ⊢ ∃ i, grundyValue (moveLeft (nim ↑n + nim ↑m) i) = ↑u ** refine' ⟨toLeftMovesAdd (Sum.inr <| toLeftMovesNim ⟨_, Ordinal.nat_cast_lt.2 h⟩), _⟩ ** case h.h.refine_2.intro.inr m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : u < n ^^^ m h : u ^^^ n < m ⊢ grundyValue (moveLeft (nim ↑n + nim ↑m) (↑toLeftMovesAdd (Sum.inr (↑toLeftMovesNim { val := ↑(u ^^^ n), property := (_ : ↑(u ^^^ n) < ↑m) })))) = ↑u ** have : n ^^^ (u ^^^ n) = u ** case this m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : u < n ^^^ m h : u ^^^ n < m ⊢ n ^^^ (u ^^^ n) = u case h.h.refine_2.intro.inr m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : u < n ^^^ m h : u ^^^ n < m this : n ^^^ (u ^^^ n) = u ⊢ grundyValue (moveLeft (nim ↑n + nim ↑m) (↑toLeftMovesAdd (Sum.inr (↑toLeftMovesNim { val := ↑(u ^^^ n), property := (_ : ↑(u ^^^ n) < ↑m) })))) = ↑u ** rw [Nat.xor_comm u, Nat.xor_cancel_left] ** case h.h.refine_2.intro.inr m✝ n : ℕ hn : ∀ (m : ℕ), m < n → ∀ (m_1 : ℕ), grundyValue (nim ↑m + nim ↑m_1) = ↑(m ^^^ m_1) m : ℕ hm : ∀ (m_1 : ℕ), m_1 < m → grundyValue (nim ↑n + nim ↑m_1) = ↑(n ^^^ m_1) u : ℕ hu : u < n ^^^ m h : u ^^^ n < m this : n ^^^ (u ^^^ n) = u ⊢ grundyValue (moveLeft (nim ↑n + nim ↑m) (↑toLeftMovesAdd (Sum.inr (↑toLeftMovesNim { val := ↑(u ^^^ n), property := (_ : ↑(u ^^^ n) < ↑m) })))) = ↑u ** simpa [hm _ h] using this ** Qed
| |
SetTheory.PGame.nim_add_nim_equiv ** n m : ℕ ⊢ nim ↑n + nim ↑m ≈ nim ↑(n ^^^ m) ** rw [← grundyValue_eq_iff_equiv_nim, grundyValue_nim_add_nim] ** Qed
| |
SetTheory.PGame.grundyValue_add ** G H : PGame inst✝¹ : Impartial G inst✝ : Impartial H n m : ℕ hG : grundyValue G = ↑n hH : grundyValue H = ↑m ⊢ grundyValue (G + H) = ↑(n ^^^ m) ** rw [← nim_grundyValue (n ^^^ m), grundyValue_eq_iff_equiv] ** G H : PGame inst✝¹ : Impartial G inst✝ : Impartial H n m : ℕ hG : grundyValue G = ↑n hH : grundyValue H = ↑m ⊢ G + H ≈ nim ↑(n ^^^ m) ** refine' Equiv.trans _ nim_add_nim_equiv ** G H : PGame inst✝¹ : Impartial G inst✝ : Impartial H n m : ℕ hG : grundyValue G = ↑n hH : grundyValue H = ↑m ⊢ G + H ≈ nim ↑n + nim ↑m ** convert add_congr (equiv_nim_grundyValue G) (equiv_nim_grundyValue H) <;> simp only [hG, hH] ** Qed
| |
SetTheory.Game.not_le ** ⊢ ∀ {x y : Game}, ¬x ≤ y ↔ y ⧏ x ** rintro ⟨x⟩ ⟨y⟩ ** case mk.mk x✝ : Game x : PGame y✝ : Game y : PGame ⊢ ¬Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y ↔ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x ** exact PGame.not_le ** Qed
| |
SetTheory.Game.not_lf ** ⊢ ∀ {x y : Game}, ¬x ⧏ y ↔ y ≤ x ** rintro ⟨x⟩ ⟨y⟩ ** case mk.mk x✝ : Game x : PGame y✝ : Game y : PGame ⊢ ¬Quot.mk Setoid.r x ⧏ Quot.mk Setoid.r y ↔ Quot.mk Setoid.r y ≤ Quot.mk Setoid.r x ** exact PGame.not_lf ** Qed
| |
SetTheory.Game.add_lf_add_right ** ⊢ ∀ {b c : Game}, b ⧏ c → ∀ (a : Game), b + a ⧏ c + a ** rintro ⟨b⟩ ⟨c⟩ h ⟨a⟩ ** case mk.mk.mk b✝ : Game b : PGame c✝ : Game c : PGame h : Quot.mk Setoid.r b ⧏ Quot.mk Setoid.r c a✝ : Game a : PGame ⊢ Quot.mk Setoid.r b + Quot.mk Setoid.r a ⧏ Quot.mk Setoid.r c + Quot.mk Setoid.r a ** apply PGame.add_lf_add_right h ** Qed
| |
SetTheory.Game.add_lf_add_left ** ⊢ ∀ {b c : Game}, b ⧏ c → ∀ (a : Game), a + b ⧏ a + c ** rintro ⟨b⟩ ⟨c⟩ h ⟨a⟩ ** case mk.mk.mk b✝ : Game b : PGame c✝ : Game c : PGame h : Quot.mk Setoid.r b ⧏ Quot.mk Setoid.r c a✝ : Game a : PGame ⊢ Quot.mk Setoid.r a + Quot.mk Setoid.r b ⧏ Quot.mk Setoid.r a + Quot.mk Setoid.r c ** apply PGame.add_lf_add_left h ** Qed
| |
SetTheory.PGame.quot_eq_of_mk'_quot_eq ** x y : PGame L : LeftMoves x ≃ LeftMoves y R : RightMoves x ≃ RightMoves y hl : ∀ (i : LeftMoves x), Quotient.mk setoid (moveLeft x i) = Quotient.mk setoid (moveLeft y (↑L i)) hr : ∀ (j : RightMoves x), Quotient.mk setoid (moveRight x j) = Quotient.mk setoid (moveRight y (↑R j)) ⊢ Quotient.mk setoid x = Quotient.mk setoid y ** exact Quot.sound (equiv_of_mk_equiv L R (fun _ => Game.PGame.equiv_iff_game_eq.2 (hl _))
(fun _ => Game.PGame.equiv_iff_game_eq.2 (hr _))) ** Qed
| |
SetTheory.PGame.mul_moveLeft_inl ** x y : PGame i : LeftMoves x j : LeftMoves y ⊢ moveLeft (x * y) (↑toLeftMovesMul (Sum.inl (i, j))) = moveLeft x i * y + x * moveLeft y j - moveLeft x i * moveLeft y j ** cases x ** case mk y : PGame j : LeftMoves y α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame i : LeftMoves (mk α✝ β✝ a✝¹ a✝) ⊢ moveLeft (mk α✝ β✝ a✝¹ a✝ * y) (↑toLeftMovesMul (Sum.inl (i, j))) = moveLeft (mk α✝ β✝ a✝¹ a✝) i * y + mk α✝ β✝ a✝¹ a✝ * moveLeft y j - moveLeft (mk α✝ β✝ a✝¹ a✝) i * moveLeft y j ** cases y ** case mk.mk α✝¹ β✝¹ : Type u_1 a✝³ : α✝¹ → PGame a✝² : β✝¹ → PGame i : LeftMoves (mk α✝¹ β✝¹ a✝³ a✝²) α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame j : LeftMoves (mk α✝ β✝ a✝¹ a✝) ⊢ moveLeft (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝) (↑toLeftMovesMul (Sum.inl (i, j))) = moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * moveLeft (mk α✝ β✝ a✝¹ a✝) j - moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i * moveLeft (mk α✝ β✝ a✝¹ a✝) j ** rfl ** Qed
| |
SetTheory.PGame.mul_moveLeft_inr ** x y : PGame i : RightMoves x j : RightMoves y ⊢ moveLeft (x * y) (↑toLeftMovesMul (Sum.inr (i, j))) = moveRight x i * y + x * moveRight y j - moveRight x i * moveRight y j ** cases x ** case mk y : PGame j : RightMoves y α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame i : RightMoves (mk α✝ β✝ a✝¹ a✝) ⊢ moveLeft (mk α✝ β✝ a✝¹ a✝ * y) (↑toLeftMovesMul (Sum.inr (i, j))) = moveRight (mk α✝ β✝ a✝¹ a✝) i * y + mk α✝ β✝ a✝¹ a✝ * moveRight y j - moveRight (mk α✝ β✝ a✝¹ a✝) i * moveRight y j ** cases y ** case mk.mk α✝¹ β✝¹ : Type u_1 a✝³ : α✝¹ → PGame a✝² : β✝¹ → PGame i : RightMoves (mk α✝¹ β✝¹ a✝³ a✝²) α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame j : RightMoves (mk α✝ β✝ a✝¹ a✝) ⊢ moveLeft (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝) (↑toLeftMovesMul (Sum.inr (i, j))) = moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * moveRight (mk α✝ β✝ a✝¹ a✝) j - moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i * moveRight (mk α✝ β✝ a✝¹ a✝) j ** rfl ** Qed
| |
SetTheory.PGame.mul_moveRight_inl ** x y : PGame i : LeftMoves x j : RightMoves y ⊢ moveRight (x * y) (↑toRightMovesMul (Sum.inl (i, j))) = moveLeft x i * y + x * moveRight y j - moveLeft x i * moveRight y j ** cases x ** case mk y : PGame j : RightMoves y α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame i : LeftMoves (mk α✝ β✝ a✝¹ a✝) ⊢ moveRight (mk α✝ β✝ a✝¹ a✝ * y) (↑toRightMovesMul (Sum.inl (i, j))) = moveLeft (mk α✝ β✝ a✝¹ a✝) i * y + mk α✝ β✝ a✝¹ a✝ * moveRight y j - moveLeft (mk α✝ β✝ a✝¹ a✝) i * moveRight y j ** cases y ** case mk.mk α✝¹ β✝¹ : Type u_1 a✝³ : α✝¹ → PGame a✝² : β✝¹ → PGame i : LeftMoves (mk α✝¹ β✝¹ a✝³ a✝²) α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame j : RightMoves (mk α✝ β✝ a✝¹ a✝) ⊢ moveRight (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝) (↑toRightMovesMul (Sum.inl (i, j))) = moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * moveRight (mk α✝ β✝ a✝¹ a✝) j - moveLeft (mk α✝¹ β✝¹ a✝³ a✝²) i * moveRight (mk α✝ β✝ a✝¹ a✝) j ** rfl ** Qed
| |
SetTheory.PGame.mul_moveRight_inr ** x y : PGame i : RightMoves x j : LeftMoves y ⊢ moveRight (x * y) (↑toRightMovesMul (Sum.inr (i, j))) = moveRight x i * y + x * moveLeft y j - moveRight x i * moveLeft y j ** cases x ** case mk y : PGame j : LeftMoves y α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame i : RightMoves (mk α✝ β✝ a✝¹ a✝) ⊢ moveRight (mk α✝ β✝ a✝¹ a✝ * y) (↑toRightMovesMul (Sum.inr (i, j))) = moveRight (mk α✝ β✝ a✝¹ a✝) i * y + mk α✝ β✝ a✝¹ a✝ * moveLeft y j - moveRight (mk α✝ β✝ a✝¹ a✝) i * moveLeft y j ** cases y ** case mk.mk α✝¹ β✝¹ : Type u_1 a✝³ : α✝¹ → PGame a✝² : β✝¹ → PGame i : RightMoves (mk α✝¹ β✝¹ a✝³ a✝²) α✝ β✝ : Type u_1 a✝¹ : α✝ → PGame a✝ : β✝ → PGame j : LeftMoves (mk α✝ β✝ a✝¹ a✝) ⊢ moveRight (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝) (↑toRightMovesMul (Sum.inr (i, j))) = moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * moveLeft (mk α✝ β✝ a✝¹ a✝) j - moveRight (mk α✝¹ β✝¹ a✝³ a✝²) i * moveLeft (mk α✝ β✝ a✝¹ a✝) j ** rfl ** Qed
| |
SetTheory.PGame.leftMoves_mul_cases ** x y : PGame k : LeftMoves (x * y) P : LeftMoves (x * y) → Prop hl : ∀ (ix : LeftMoves x) (iy : LeftMoves y), P (↑toLeftMovesMul (Sum.inl (ix, iy))) hr : ∀ (jx : RightMoves x) (jy : RightMoves y), P (↑toLeftMovesMul (Sum.inr (jx, jy))) ⊢ P k ** rw [← toLeftMovesMul.apply_symm_apply k] ** x y : PGame k : LeftMoves (x * y) P : LeftMoves (x * y) → Prop hl : ∀ (ix : LeftMoves x) (iy : LeftMoves y), P (↑toLeftMovesMul (Sum.inl (ix, iy))) hr : ∀ (jx : RightMoves x) (jy : RightMoves y), P (↑toLeftMovesMul (Sum.inr (jx, jy))) ⊢ P (↑toLeftMovesMul (↑toLeftMovesMul.symm k)) ** rcases toLeftMovesMul.symm k with (⟨ix, iy⟩ | ⟨jx, jy⟩) ** case inl.mk x y : PGame k : LeftMoves (x * y) P : LeftMoves (x * y) → Prop hl : ∀ (ix : LeftMoves x) (iy : LeftMoves y), P (↑toLeftMovesMul (Sum.inl (ix, iy))) hr : ∀ (jx : RightMoves x) (jy : RightMoves y), P (↑toLeftMovesMul (Sum.inr (jx, jy))) ix : LeftMoves x iy : LeftMoves y ⊢ P (↑toLeftMovesMul (Sum.inl (ix, iy))) ** apply hl ** case inr.mk x y : PGame k : LeftMoves (x * y) P : LeftMoves (x * y) → Prop hl : ∀ (ix : LeftMoves x) (iy : LeftMoves y), P (↑toLeftMovesMul (Sum.inl (ix, iy))) hr : ∀ (jx : RightMoves x) (jy : RightMoves y), P (↑toLeftMovesMul (Sum.inr (jx, jy))) jx : RightMoves x jy : RightMoves y ⊢ P (↑toLeftMovesMul (Sum.inr (jx, jy))) ** apply hr ** Qed
| |
SetTheory.PGame.rightMoves_mul_cases ** x y : PGame k : RightMoves (x * y) P : RightMoves (x * y) → Prop hl : ∀ (ix : LeftMoves x) (jy : RightMoves y), P (↑toRightMovesMul (Sum.inl (ix, jy))) hr : ∀ (jx : RightMoves x) (iy : LeftMoves y), P (↑toRightMovesMul (Sum.inr (jx, iy))) ⊢ P k ** rw [← toRightMovesMul.apply_symm_apply k] ** x y : PGame k : RightMoves (x * y) P : RightMoves (x * y) → Prop hl : ∀ (ix : LeftMoves x) (jy : RightMoves y), P (↑toRightMovesMul (Sum.inl (ix, jy))) hr : ∀ (jx : RightMoves x) (iy : LeftMoves y), P (↑toRightMovesMul (Sum.inr (jx, iy))) ⊢ P (↑toRightMovesMul (↑toRightMovesMul.symm k)) ** rcases toRightMovesMul.symm k with (⟨ix, iy⟩ | ⟨jx, jy⟩) ** case inl.mk x y : PGame k : RightMoves (x * y) P : RightMoves (x * y) → Prop hl : ∀ (ix : LeftMoves x) (jy : RightMoves y), P (↑toRightMovesMul (Sum.inl (ix, jy))) hr : ∀ (jx : RightMoves x) (iy : LeftMoves y), P (↑toRightMovesMul (Sum.inr (jx, iy))) ix : LeftMoves x iy : RightMoves y ⊢ P (↑toRightMovesMul (Sum.inl (ix, iy))) ** apply hl ** case inr.mk x y : PGame k : RightMoves (x * y) P : RightMoves (x * y) → Prop hl : ∀ (ix : LeftMoves x) (jy : RightMoves y), P (↑toRightMovesMul (Sum.inl (ix, jy))) hr : ∀ (jx : RightMoves x) (iy : LeftMoves y), P (↑toRightMovesMul (Sum.inr (jx, iy))) jx : RightMoves x jy : LeftMoves y ⊢ P (↑toRightMovesMul (Sum.inr (jx, jy))) ** apply hr ** Qed
| |
SetTheory.PGame.quot_left_distrib ** x y z : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame ⊢ Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** let x := mk xl xr xL xR ** x✝ y z : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR ⊢ Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** let y := mk yl yr yL yR ** x✝ y✝ z : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR ⊢ Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** let z := mk zl zr zL zR ** x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** refine' quot_eq_of_mk'_quot_eq _ _ _ _ ** case refine'_1 x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) ≃ LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) ** fconstructor ** case refine'_1.toFun x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) → LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) ** rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk] ** case refine'_1.invFun x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) → LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) ** rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk] ** case refine'_1.left_inv x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftInverse (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)) ** rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl ** case refine'_1.right_inv x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ Function.RightInverse (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)) ** rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl ** case refine'_2 x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) ≃ RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) ** fconstructor ** case refine'_2.toFun x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) → RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) ** rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk] ** case refine'_2.invFun x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) → RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) ** rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk] ** case refine'_2.left_inv x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftInverse (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)) ** rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl ** case refine'_2.right_inv x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ Function.RightInverse (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)) ** rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl ** case refine'_3 x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ ∀ (i : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) i) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } i)) ** rintro (⟨i, j | k⟩ | ⟨i, j | k⟩) ** case refine'_3.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yl ⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inl (i, Sum.inl j))) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } (Sum.inl (i, Sum.inl j)))) ** change
⟦xL i * (y + z) + x * (yL j + z) - xL i * (yL j + z)⟧ =
⟦xL i * y + x * yL j - xL i * yL j + x * z⟧ ** case refine'_3.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yl ⊢ Quotient.mk setoid (xL i * (y + z) + x * (yL j + z) - xL i * (yL j + z)) = Quotient.mk setoid (xL i * y + x * yL j - xL i * yL j + x * z) ** simp only [quot_sub, quot_add] ** case refine'_3.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR + mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j + mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j + mk zl zr zL zR)) = Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) - Quotient.mk setoid (xL i * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (xL i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yl ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * (yL j + mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j + mk zl zr zL zR)) = Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) - Quotient.mk setoid (xL i * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (mk xl xr xL xR) (yL j) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yl ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j + mk zl zr zL zR)) = Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) - Quotient.mk setoid (xL i * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (xL i) (yL j) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yl ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) - (Quotient.mk setoid (xL i * yL j) + Quotient.mk setoid (xL i * mk zl zr zL zR)) = Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) - Quotient.mk setoid (xL i * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** abel ** case refine'_3.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zl ⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inl (i, Sum.inr k))) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } (Sum.inl (i, Sum.inr k)))) ** change
⟦xL i * (y + z) + x * (y + zL k) - xL i * (y + zL k)⟧ =
⟦x * y + (xL i * z + x * zL k - xL i * zL k)⟧ ** case refine'_3.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zl ⊢ Quotient.mk setoid (xL i * (y + z) + x * (y + zL k) - xL i * (y + zL k)) = Quotient.mk setoid (x * y + (xL i * z + x * zL k - xL i * zL k)) ** simp only [quot_sub, quot_add] ** case refine'_3.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR + mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zL k)) - Quotient.mk setoid (xL i * (mk yl yr yL yR + zL k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) - Quotient.mk setoid (xL i * zL k)) ** rw [quot_left_distrib (xL i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zl ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zL k)) - Quotient.mk setoid (xL i * (mk yl yr yL yR + zL k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) - Quotient.mk setoid (xL i * zL k)) ** rw [quot_left_distrib (mk xl xr xL xR) (mk yl yr yL yR) (zL k)] ** case refine'_3.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zl ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) - Quotient.mk setoid (xL i * (mk yl yr yL yR + zL k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) - Quotient.mk setoid (xL i * zL k)) ** rw [quot_left_distrib (xL i) (mk yl yr yL yR) (zL k)] ** case refine'_3.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zl ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) - (Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * zL k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) - Quotient.mk setoid (xL i * zL k)) ** abel ** case refine'_3.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yr ⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inr (i, Sum.inl j))) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } (Sum.inr (i, Sum.inl j)))) ** change
⟦xR i * (y + z) + x * (yR j + z) - xR i * (yR j + z)⟧ =
⟦xR i * y + x * yR j - xR i * yR j + x * z⟧ ** case refine'_3.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yr ⊢ Quotient.mk setoid (xR i * (y + z) + x * (yR j + z) - xR i * (yR j + z)) = Quotient.mk setoid (xR i * y + x * yR j - xR i * yR j + x * z) ** simp only [quot_sub, quot_add] ** case refine'_3.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR + mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j + mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j + mk zl zr zL zR)) = Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) - Quotient.mk setoid (xR i * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (xR i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yr ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * (yR j + mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j + mk zl zr zL zR)) = Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) - Quotient.mk setoid (xR i * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (mk xl xr xL xR) (yR j) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yr ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j + mk zl zr zL zR)) = Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) - Quotient.mk setoid (xR i * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (xR i) (yR j) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yr ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) - (Quotient.mk setoid (xR i * yR j) + Quotient.mk setoid (xR i * mk zl zr zL zR)) = Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) - Quotient.mk setoid (xR i * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** abel ** case refine'_3.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zr ⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inr (i, Sum.inr k))) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } (Sum.inr (i, Sum.inr k)))) ** change
⟦xR i * (y + z) + x * (y + zR k) - xR i * (y + zR k)⟧ =
⟦x * y + (xR i * z + x * zR k - xR i * zR k)⟧ ** case refine'_3.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zr ⊢ Quotient.mk setoid (xR i * (y + z) + x * (y + zR k) - xR i * (y + zR k)) = Quotient.mk setoid (x * y + (xR i * z + x * zR k - xR i * zR k)) ** simp only [quot_sub, quot_add] ** case refine'_3.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR + mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zR k)) - Quotient.mk setoid (xR i * (mk yl yr yL yR + zR k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) - Quotient.mk setoid (xR i * zR k)) ** rw [quot_left_distrib (xR i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zr ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zR k)) - Quotient.mk setoid (xR i * (mk yl yr yL yR + zR k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) - Quotient.mk setoid (xR i * zR k)) ** rw [quot_left_distrib (mk xl xr xL xR) (mk yl yr yL yR) (zR k)] ** case refine'_3.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zr ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) - Quotient.mk setoid (xR i * (mk yl yr yL yR + zR k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) - Quotient.mk setoid (xR i * zR k)) ** rw [quot_left_distrib (xR i) (mk yl yr yL yR) (zR k)] ** case refine'_3.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zr ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) - (Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * zR k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) - Quotient.mk setoid (xR i * zR k)) ** abel ** case refine'_4 x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ ∀ (j : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) j) = Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } j)) ** rintro (⟨i, j | k⟩ | ⟨i, j | k⟩) ** case refine'_4.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yr ⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inl (i, Sum.inl j))) = Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } (Sum.inl (i, Sum.inl j)))) ** change
⟦xL i * (y + z) + x * (yR j + z) - xL i * (yR j + z)⟧ =
⟦xL i * y + x * yR j - xL i * yR j + x * z⟧ ** case refine'_4.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yr ⊢ Quotient.mk setoid (xL i * (y + z) + x * (yR j + z) - xL i * (yR j + z)) = Quotient.mk setoid (xL i * y + x * yR j - xL i * yR j + x * z) ** simp only [quot_sub, quot_add] ** case refine'_4.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR + mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j + mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j + mk zl zr zL zR)) = Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) - Quotient.mk setoid (xL i * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (xL i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yr ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * (yR j + mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j + mk zl zr zL zR)) = Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) - Quotient.mk setoid (xL i * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (mk xl xr xL xR) (yR j) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yr ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j + mk zl zr zL zR)) = Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) - Quotient.mk setoid (xL i * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (xL i) (yR j) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl j : yr ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) - (Quotient.mk setoid (xL i * yR j) + Quotient.mk setoid (xL i * mk zl zr zL zR)) = Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yR j) - Quotient.mk setoid (xL i * yR j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** abel ** case refine'_4.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zr ⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inl (i, Sum.inr k))) = Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } (Sum.inl (i, Sum.inr k)))) ** change
⟦xL i * (y + z) + x * (y + zR k) - xL i * (y + zR k)⟧ =
⟦x * y + (xL i * z + x * zR k - xL i * zR k)⟧ ** case refine'_4.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zr ⊢ Quotient.mk setoid (xL i * (y + z) + x * (y + zR k) - xL i * (y + zR k)) = Quotient.mk setoid (x * y + (xL i * z + x * zR k - xL i * zR k)) ** simp only [quot_sub, quot_add] ** case refine'_4.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR + mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zR k)) - Quotient.mk setoid (xL i * (mk yl yr yL yR + zR k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) - Quotient.mk setoid (xL i * zR k)) ** rw [quot_left_distrib (xL i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zr ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zR k)) - Quotient.mk setoid (xL i * (mk yl yr yL yR + zR k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) - Quotient.mk setoid (xL i * zR k)) ** rw [quot_left_distrib (mk xl xr xL xR) (mk yl yr yL yR) (zR k)] ** case refine'_4.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zr ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) - Quotient.mk setoid (xL i * (mk yl yr yL yR + zR k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) - Quotient.mk setoid (xL i * zR k)) ** rw [quot_left_distrib (xL i) (mk yl yr yL yR) (zR k)] ** case refine'_4.inl.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xl k : zr ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zR k)) - (Quotient.mk setoid (xL i * mk yl yr yL yR) + Quotient.mk setoid (xL i * zR k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xL i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zR k) - Quotient.mk setoid (xL i * zR k)) ** abel ** case refine'_4.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yl ⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inr (i, Sum.inl j))) = Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } (Sum.inr (i, Sum.inl j)))) ** change
⟦xR i * (y + z) + x * (yL j + z) - xR i * (yL j + z)⟧ =
⟦xR i * y + x * yL j - xR i * yL j + x * z⟧ ** case refine'_4.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yl ⊢ Quotient.mk setoid (xR i * (y + z) + x * (yL j + z) - xR i * (yL j + z)) = Quotient.mk setoid (xR i * y + x * yL j - xR i * yL j + x * z) ** simp only [quot_sub, quot_add] ** case refine'_4.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR + mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j + mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j + mk zl zr zL zR)) = Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) - Quotient.mk setoid (xR i * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (xR i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yl ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * (yL j + mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j + mk zl zr zL zR)) = Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) - Quotient.mk setoid (xR i * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (mk xl xr xL xR) (yL j) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yl ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j + mk zl zr zL zR)) = Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) - Quotient.mk setoid (xR i * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** rw [quot_left_distrib (xR i) (yL j) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inl x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr j : yl ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR)) - (Quotient.mk setoid (xR i * yL j) + Quotient.mk setoid (xR i * mk zl zr zL zR)) = Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * yL j) - Quotient.mk setoid (xR i * yL j) + Quotient.mk setoid (mk xl xr xL xR * mk zl zr zL zR) ** abel ** case refine'_4.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zl ⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR)) (Sum.inr (i, Sum.inr k))) = Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val)), invFun := fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR + mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR + mk xl xr xL xR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inl (fst, val))) fun val => Sum.inr (Sum.inl (fst, val))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Sum.inl (Sum.inr (fst, val))) fun val => Sum.inr (Sum.inr (fst, val))) ((fun a => Sum.casesOn a (fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inl snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inl snd)) fun val => Sum.casesOn val (fun val => Prod.casesOn val fun fst snd => Sum.inl (fst, Sum.inr snd)) fun val => Prod.casesOn val fun fst snd => Sum.inr (fst, Sum.inr snd)) x) = x) } (Sum.inr (i, Sum.inr k)))) ** change
⟦xR i * (y + z) + x * (y + zL k) - xR i * (y + zL k)⟧ =
⟦x * y + (xR i * z + x * zL k - xR i * zL k)⟧ ** case refine'_4.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zl ⊢ Quotient.mk setoid (xR i * (y + z) + x * (y + zL k) - xR i * (y + zL k)) = Quotient.mk setoid (x * y + (xR i * z + x * zL k - xR i * zL k)) ** simp only [quot_sub, quot_add] ** case refine'_4.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR + mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zL k)) - Quotient.mk setoid (xR i * (mk yl yr yL yR + zL k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) - Quotient.mk setoid (xR i * zL k)) ** rw [quot_left_distrib (xR i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zl ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR + zL k)) - Quotient.mk setoid (xR i * (mk yl yr yL yR + zL k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) - Quotient.mk setoid (xR i * zL k)) ** rw [quot_left_distrib (mk xl xr xL xR) (mk yl yr yL yR) (zL k)] ** case refine'_4.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zl ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) - Quotient.mk setoid (xR i * (mk yl yr yL yR + zL k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) - Quotient.mk setoid (xR i * zL k)) ** rw [quot_left_distrib (xR i) (mk yl yr yL yR) (zL k)] ** case refine'_4.inr.mk.inr x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR i : xr k : zl ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * mk zl zr zL zR) + (Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + Quotient.mk setoid (mk xl xr xL xR * zL k)) - (Quotient.mk setoid (xR i * mk yl yr yL yR) + Quotient.mk setoid (xR i * zL k)) = Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR) + (Quotient.mk setoid (xR i * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * zL k) - Quotient.mk setoid (xR i * zL k)) ** abel ** xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x✝ : ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame), (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd)) Prod.instWellFoundedRelationProd).1 y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } → Quotient.mk setoid (y.1 * (y.2.1 + y.2.2)) = Quotient.mk setoid (y.1 * y.2.1) + Quotient.mk setoid (y.1 * y.2.2) i : xr k : zl ⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd)) Prod.instWellFoundedRelationProd).1 { fst := xR i, snd := { fst := mk yl yr yL yR, snd := zL k } } { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } ** pgame_wf_tac ** Qed
| |
SetTheory.PGame.quot_left_distrib_sub ** x y z : PGame ⊢ Quotient.mk setoid (x * (y - z)) = Quotient.mk setoid (x * y) - Quotient.mk setoid (x * z) ** change (⟦x * (y + -z)⟧ : Game) = ⟦x * y⟧ + -⟦x * z⟧ ** x y z : PGame ⊢ Quotient.mk setoid (x * (y + -z)) = Quotient.mk setoid (x * y) + -Quotient.mk setoid (x * z) ** rw [quot_left_distrib, quot_mul_neg] ** Qed
| |
SetTheory.PGame.quot_right_distrib ** x y z : PGame ⊢ Quotient.mk setoid ((x + y) * z) = Quotient.mk setoid (x * z) + Quotient.mk setoid (y * z) ** simp only [quot_mul_comm, quot_left_distrib] ** Qed
| |
SetTheory.PGame.quot_right_distrib_sub ** x y z : PGame ⊢ Quotient.mk setoid ((y - z) * x) = Quotient.mk setoid (y * x) - Quotient.mk setoid (z * x) ** change (⟦(y + -z) * x⟧ : Game) = ⟦y * x⟧ + -⟦z * x⟧ ** x y z : PGame ⊢ Quotient.mk setoid ((y + -z) * x) = Quotient.mk setoid (y * x) + -Quotient.mk setoid (z * x) ** rw [quot_right_distrib, quot_neg_mul] ** Qed
| |
SetTheory.PGame.quot_mul_assoc ** x y z : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame ⊢ Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) = Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) ** let x := mk xl xr xL xR ** x✝ y z : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR ⊢ Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) = Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) ** let y := mk yl yr yL yR ** x✝ y✝ z : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR ⊢ Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) = Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) ** let z := mk zl zr zL zR ** x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) = Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) ** refine' quot_eq_of_mk'_quot_eq _ _ _ _ ** case refine'_1 x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) ≃ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) ** fconstructor ** case refine'_1.toFun x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) → LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) ** rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩) <;>
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk] ** case refine'_1.invFun x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) → LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) ** rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩) <;>
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk] ** case refine'_1.left_inv x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftInverse (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)) ** rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩) <;> rfl ** case refine'_1.right_inv x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ Function.RightInverse (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)) ** rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩) <;> rfl ** case refine'_2 x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) ≃ RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) ** fconstructor ** case refine'_2.toFun x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) → RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) ** rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩) <;>
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk] ** case refine'_2.invFun x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) → RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) ** rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩) <;>
solve_by_elim (config := { maxDepth := 8 }) [Sum.inl, Sum.inr, Prod.mk] ** case refine'_2.left_inv x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ LeftInverse (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)) ** rintro (⟨⟨_, _⟩ | ⟨_, _⟩, _⟩ | ⟨⟨_, _⟩ | ⟨_, _⟩, _⟩) <;> rfl ** case refine'_2.right_inv x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ Function.RightInverse (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)) ** rintro (⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, ⟨_, _⟩ | ⟨_, _⟩⟩) <;> rfl ** case refine'_3 x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ ∀ (i : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) i) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } i)) ** rintro (⟨⟨i, j⟩ | ⟨i, j⟩, k⟩ | ⟨⟨i, j⟩ | ⟨i, j⟩, k⟩) ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inl (Sum.inl (i, j), k))) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } (Sum.inl (Sum.inl (i, j), k)))) ** change
⟦(xL i * y + x * yL j - xL i * yL j) * z + x * y * zL k -
(xL i * y + x * yL j - xL i * yL j) * zL k⟧ =
⟦xL i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) -
xL i * (yL j * z + y * zL k - yL j * zL k)⟧ ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid ((xL i * y + x * yL j - xL i * yL j) * z + x * y * zL k - (xL i * y + x * yL j - xL i * yL j) * zL k) = Quotient.mk setoid (xL i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) - xL i * (yL j * z + y * zL k - yL j * zL k)) ** simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib] ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) - Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xL i * yL j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) ** rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) - Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xL i * yL j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xL i * yL j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) ** rw [quot_mul_assoc (xL i) (yL j) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xL i * yL j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)] ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xL i * yL j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) ** rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zL k)] ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xL i * yL j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zL k)] ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) - Quotient.mk setoid (xL i * yL j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) ** rw [quot_mul_assoc (xL i) (yL j) (zL k)] ** case refine'_3.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yL j * zL k))) ** abel ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inl (Sum.inr (i, j), k))) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } (Sum.inl (Sum.inr (i, j), k)))) ** change
⟦(xR i * y + x * yR j - xR i * yR j) * z + x * y * zL k -
(xR i * y + x * yR j - xR i * yR j) * zL k⟧ =
⟦xR i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) -
xR i * (yR j * z + y * zL k - yR j * zL k)⟧ ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid ((xR i * y + x * yR j - xR i * yR j) * z + x * y * zL k - (xR i * y + x * yR j - xR i * yR j) * zL k) = Quotient.mk setoid (xR i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) - xR i * (yR j * z + y * zL k - yR j * zL k)) ** simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib] ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) - Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xR i * yR j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) ** rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) - Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xR i * yR j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xR i * yR j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) ** rw [quot_mul_assoc (xR i) (yR j) (mk zl zr zL zR)] ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xR i * yR j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)] ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xR i * yR j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) ** rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zL k)] ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xR i * yR j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zL k)] ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) - Quotient.mk setoid (xR i * yR j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) ** rw [quot_mul_assoc (xR i) (yR j) (zL k)] ** case refine'_3.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yR j * zL k))) ** abel ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inr (Sum.inl (i, j), k))) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } (Sum.inr (Sum.inl (i, j), k)))) ** change
⟦(xL i * y + x * yR j - xL i * yR j) * z + x * y * zR k -
(xL i * y + x * yR j - xL i * yR j) * zR k⟧ =
⟦xL i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) -
xL i * (yR j * z + y * zR k - yR j * zR k)⟧ ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid ((xL i * y + x * yR j - xL i * yR j) * z + x * y * zR k - (xL i * y + x * yR j - xL i * yR j) * zR k) = Quotient.mk setoid (xL i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) - xL i * (yR j * z + y * zR k - yR j * zR k)) ** simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib] ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) - Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xL i * yR j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) ** rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) - Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xL i * yR j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xL i * yR j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) ** rw [quot_mul_assoc (xL i) (yR j) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xL i * yR j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)] ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xL i * yR j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) ** rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zR k)] ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xL i * yR j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zR k)] ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) - Quotient.mk setoid (xL i * yR j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) ** rw [quot_mul_assoc (xL i) (yR j) (zR k)] ** case refine'_3.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yR j * zR k))) ** abel ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (moveLeft (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inr (Sum.inr (i, j), k))) = Quotient.mk setoid (moveLeft (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : LeftMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } (Sum.inr (Sum.inr (i, j), k)))) ** change
⟦(xR i * y + x * yL j - xR i * yL j) * z + x * y * zR k -
(xR i * y + x * yL j - xR i * yL j) * zR k⟧ =
⟦xR i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) -
xR i * (yL j * z + y * zR k - yL j * zR k)⟧ ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid ((xR i * y + x * yL j - xR i * yL j) * z + x * y * zR k - (xR i * y + x * yL j - xR i * yL j) * zR k) = Quotient.mk setoid (xR i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) - xR i * (yL j * z + y * zR k - yL j * zR k)) ** simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib] ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) - Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xR i * yL j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) ** rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) - Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xR i * yL j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xR i * yL j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) ** rw [quot_mul_assoc (xR i) (yL j) (mk zl zr zL zR)] ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xR i * yL j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)] ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xR i * yL j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) ** rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zR k)] ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xR i * yL j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zR k)] ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) - Quotient.mk setoid (xR i * yL j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) ** rw [quot_mul_assoc (xR i) (yL j) (zR k)] ** case refine'_3.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yL j * zR k))) ** abel ** case refine'_4 x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR ⊢ ∀ (j : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) j) = Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } j)) ** rintro (⟨⟨i, j⟩ | ⟨i, j⟩, k⟩ | ⟨⟨i, j⟩ | ⟨i, j⟩, k⟩) ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inl (Sum.inl (i, j), k))) = Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } (Sum.inl (Sum.inl (i, j), k)))) ** change
⟦(xL i * y + x * yL j - xL i * yL j) * z + x * y * zR k -
(xL i * y + x * yL j - xL i * yL j) * zR k⟧ =
⟦xL i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) -
xL i * (yL j * z + y * zR k - yL j * zR k)⟧ ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid ((xL i * y + x * yL j - xL i * yL j) * z + x * y * zR k - (xL i * y + x * yL j - xL i * yL j) * zR k) = Quotient.mk setoid (xL i * (y * z) + x * (yL j * z + y * zR k - yL j * zR k) - xL i * (yL j * z + y * zR k - yL j * zR k)) ** simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib] ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) - Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xL i * yL j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) ** rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) - Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xL i * yL j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xL i * yL j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) ** rw [quot_mul_assoc (xL i) (yL j) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xL i * yL j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)] ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xL i * yL j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) ** rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zR k)] ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * yL j * zR k) - Quotient.mk setoid (xL i * yL j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zR k)] ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) - Quotient.mk setoid (xL i * yL j * zR k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) ** rw [quot_mul_assoc (xL i) (yL j) (zR k)] ** case refine'_4.inl.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xl j : yl ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zR k))) - (Quotient.mk setoid (xL i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xL i * (yL j * zR k))) ** abel ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inl (Sum.inr (i, j), k))) = Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } (Sum.inl (Sum.inr (i, j), k)))) ** change
⟦(xR i * y + x * yR j - xR i * yR j) * z + x * y * zR k -
(xR i * y + x * yR j - xR i * yR j) * zR k⟧ =
⟦xR i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) -
xR i * (yR j * z + y * zR k - yR j * zR k)⟧ ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid ((xR i * y + x * yR j - xR i * yR j) * z + x * y * zR k - (xR i * y + x * yR j - xR i * yR j) * zR k) = Quotient.mk setoid (xR i * (y * z) + x * (yR j * z + y * zR k - yR j * zR k) - xR i * (yR j * z + y * zR k - yR j * zR k)) ** simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib] ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) - Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xR i * yR j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) ** rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) - Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xR i * yR j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xR i * yR j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) ** rw [quot_mul_assoc (xR i) (yR j) (mk zl zr zL zR)] ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zR k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xR i * yR j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zR k)] ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zR k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xR i * yR j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) ** rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zR k)] ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * yR j * zR k) - Quotient.mk setoid (xR i * yR j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zR k)] ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) - Quotient.mk setoid (xR i * yR j * zR k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) ** rw [quot_mul_assoc (xR i) (yR j) (zR k)] ** case refine'_4.inl.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zr i : xr j : yr ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zR k))) - (Quotient.mk setoid (xR i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zR k)) - Quotient.mk setoid (xR i * (yR j * zR k))) ** abel ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inr (Sum.inl (i, j), k))) = Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } (Sum.inr (Sum.inl (i, j), k)))) ** change
⟦(xL i * y + x * yR j - xL i * yR j) * z + x * y * zL k -
(xL i * y + x * yR j - xL i * yR j) * zL k⟧ =
⟦xL i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) -
xL i * (yR j * z + y * zL k - yR j * zL k)⟧ ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid ((xL i * y + x * yR j - xL i * yR j) * z + x * y * zL k - (xL i * y + x * yR j - xL i * yR j) * zL k) = Quotient.mk setoid (xL i * (y * z) + x * (yR j * z + y * zL k - yR j * zL k) - xL i * (yR j * z + y * zL k - yR j * zL k)) ** simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib] ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (xL i * mk yl yr yL yR * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) - Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xL i * yR j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) ** rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * yR j * mk zl zr zL zR) - Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xL i * yR j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * yR j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xL i * yR j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) ** rw [quot_mul_assoc (xL i) (yR j) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xL i * yR j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)] ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xL i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xL i * yR j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) ** rw [quot_mul_assoc (xL i) (mk yl yr yL yR) (zL k)] ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * yR j * zL k) - Quotient.mk setoid (xL i * yR j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yR j) (zL k)] ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) - Quotient.mk setoid (xL i * yR j * zL k)) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) ** rw [quot_mul_assoc (xL i) (yR j) (zL k)] ** case refine'_4.inr.mk.inl.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xl j : yr ⊢ Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) - Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) = Quotient.mk setoid (xL i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yR j * zL k))) - (Quotient.mk setoid (xL i * (yR j * mk zl zr zL zR)) + Quotient.mk setoid (xL i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xL i * (yR j * zL k))) ** abel ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (moveRight (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR) (Sum.inr (Sum.inr (i, j), k))) = Quotient.mk setoid (moveRight (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR)) (↑{ toFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd)), invFun := fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd), left_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * mk yl yr yL yR * mk zl zr zL zR)), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) x) = x), right_inv := (_ : ∀ (x : RightMoves (mk xl xr xL xR * (mk yl yr yL yR * mk zl zr zL zR))), (fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inl (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd => Sum.casesOn fst (fun val => Prod.casesOn val fun fst snd_1 => Sum.inl (fst, Sum.inr (snd_1, snd))) fun val => Prod.casesOn val fun fst snd_1 => Sum.inr (fst, Sum.inl (snd_1, snd))) ((fun a => Sum.casesOn a (fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inl (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst snd => Sum.casesOn snd (fun val => Prod.casesOn val fun fst_1 snd => Sum.inr (Sum.inr (fst, fst_1), snd)) fun val => Prod.casesOn val fun fst_1 snd => Sum.inl (Sum.inr (fst, fst_1), snd)) x) = x) } (Sum.inr (Sum.inr (i, j), k)))) ** change
⟦(xR i * y + x * yL j - xR i * yL j) * z + x * y * zL k -
(xR i * y + x * yL j - xR i * yL j) * zL k⟧ =
⟦xR i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) -
xR i * (yL j * z + y * zL k - yL j * zL k)⟧ ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid ((xR i * y + x * yL j - xR i * yL j) * z + x * y * zL k - (xR i * y + x * yL j - xR i * yL j) * zL k) = Quotient.mk setoid (xR i * (y * z) + x * (yL j * z + y * zL k - yL j * zL k) - xR i * (yL j * z + y * zL k - yL j * zL k)) ** simp only [quot_sub, quot_add, quot_right_distrib_sub, quot_right_distrib,
quot_left_distrib_sub, quot_left_distrib] ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (xR i * mk yl yr yL yR * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) - Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xR i * yL j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) ** rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * yL j * mk zl zr zL zR) - Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xR i * yL j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * yL j * mk zl zr zL zR) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xR i * yL j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) ** rw [quot_mul_assoc (xR i) (yL j) (mk zl zr zL zR)] ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * mk yl yr yL yR * zL k) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xR i * yL j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (mk yl yr yL yR) (zL k)] ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xR i * mk yl yr yL yR * zL k) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xR i * yL j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) ** rw [quot_mul_assoc (xR i) (mk yl yr yL yR) (zL k)] ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * yL j * zL k) - Quotient.mk setoid (xR i * yL j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) ** rw [quot_mul_assoc (mk xl xr xL xR) (yL j) (zL k)] ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) - Quotient.mk setoid (xR i * yL j * zL k)) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) ** rw [quot_mul_assoc (xR i) (yL j) (zL k)] ** case refine'_4.inr.mk.inr.mk x✝ y✝ z✝ : PGame xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x : PGame := mk xl xr xL xR y : PGame := mk yl yr yL yR z : PGame := mk zl zr zL zR k : zl i : xr j : yl ⊢ Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) - Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - (Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) + Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) = Quotient.mk setoid (xR i * (mk yl yr yL yR * mk zl zr zL zR)) + (Quotient.mk setoid (mk xl xr xL xR * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (mk xl xr xL xR * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (mk xl xr xL xR * (yL j * zL k))) - (Quotient.mk setoid (xR i * (yL j * mk zl zr zL zR)) + Quotient.mk setoid (xR i * (mk yl yr yL yR * zL k)) - Quotient.mk setoid (xR i * (yL j * zL k))) ** abel ** xl xr : Type u_1 xL : xl → PGame xR : xr → PGame yl yr : Type u_1 yL : yl → PGame yR : yr → PGame zl zr : Type u_1 zL : zl → PGame zR : zr → PGame x✝ : ∀ (y : (_ : PGame) ×' (_ : PGame) ×' PGame), (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd)) Prod.instWellFoundedRelationProd).1 y { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } → Quotient.mk setoid (y.1 * y.2.1 * y.2.2) = Quotient.mk setoid (y.1 * (y.2.1 * y.2.2)) k : zl i : xr j : yl ⊢ (invImage (fun a => PSigma.casesOn a fun x snd => PSigma.casesOn snd fun y snd => (x, y, snd)) Prod.instWellFoundedRelationProd).1 { fst := xR i, snd := { fst := yL j, snd := zL k } } { fst := mk xl xr xL xR, snd := { fst := mk yl yr yL yR, snd := mk zl zr zL zR } } ** pgame_wf_tac ** Qed
| |
SetTheory.PGame.invVal_isEmpty ** l r : Type u b : Bool L : l → PGame R : r → PGame IHl : l → PGame IHr : r → PGame i : InvTy l r b inst✝¹ : IsEmpty l inst✝ : IsEmpty r ⊢ invVal L R IHl IHr i = 0 ** cases' i with a _ a _ a _ a ** case left₁ l r : Type u L : l → PGame R : r → PGame IHl : l → PGame IHr : r → PGame inst✝¹ : IsEmpty l inst✝ : IsEmpty r a : r a✝ : InvTy l r false ⊢ invVal L R IHl IHr (InvTy.left₁ a a✝) = 0 case left₂ l r : Type u L : l → PGame R : r → PGame IHl : l → PGame IHr : r → PGame inst✝¹ : IsEmpty l inst✝ : IsEmpty r a : l a✝ : InvTy l r true ⊢ invVal L R IHl IHr (InvTy.left₂ a a✝) = 0 case right₁ l r : Type u L : l → PGame R : r → PGame IHl : l → PGame IHr : r → PGame inst✝¹ : IsEmpty l inst✝ : IsEmpty r a : l a✝ : InvTy l r false ⊢ invVal L R IHl IHr (InvTy.right₁ a a✝) = 0 case right₂ l r : Type u L : l → PGame R : r → PGame IHl : l → PGame IHr : r → PGame inst✝¹ : IsEmpty l inst✝ : IsEmpty r a : r a✝ : InvTy l r true ⊢ invVal L R IHl IHr (InvTy.right₂ a a✝) = 0 ** all_goals exact isEmptyElim a ** case zero l r : Type u L : l → PGame R : r → PGame IHl : l → PGame IHr : r → PGame inst✝¹ : IsEmpty l inst✝ : IsEmpty r ⊢ invVal L R IHl IHr InvTy.zero = 0 ** rfl ** case right₂ l r : Type u L : l → PGame R : r → PGame IHl : l → PGame IHr : r → PGame inst✝¹ : IsEmpty l inst✝ : IsEmpty r a : r a✝ : InvTy l r true ⊢ invVal L R IHl IHr (InvTy.right₂ a a✝) = 0 ** exact isEmptyElim a ** Qed
| |
SetTheory.PGame.zero_lf_inv' ** xl xr : Type u_1 xL : xl → PGame xR : xr → PGame ⊢ 0 ⧏ inv' (mk xl xr xL xR) ** convert lf_mk _ _ InvTy.zero ** case h.e'_1 xl xr : Type u_1 xL : xl → PGame xR : xr → PGame ⊢ 0 = invVal (fun i => xL ↑i) xR (fun i => inv' (xL ↑i)) (fun i => inv' (xR i)) InvTy.zero ** rfl ** Qed
| |
SetTheory.PGame.inv_eq_of_equiv_zero ** x : PGame h : x ≈ 0 ⊢ x⁻¹ = 0 ** classical exact if_pos h ** x : PGame h : x ≈ 0 ⊢ x⁻¹ = 0 ** exact if_pos h ** Qed
| |
SetTheory.PGame.inv_eq_of_pos ** x : PGame h : 0 < x ⊢ x⁻¹ = inv' x ** classical exact (if_neg h.lf.not_equiv').trans (if_pos h) ** x : PGame h : 0 < x ⊢ x⁻¹ = inv' x ** exact (if_neg h.lf.not_equiv').trans (if_pos h) ** Qed
| |
SetTheory.PGame.inv_eq_of_lf_zero ** x : PGame h : x ⧏ 0 ⊢ x⁻¹ = -inv' (-x) ** classical exact (if_neg h.not_equiv).trans (if_neg h.not_gt) ** x : PGame h : x ⧏ 0 ⊢ x⁻¹ = -inv' (-x) ** exact (if_neg h.not_equiv).trans (if_neg h.not_gt) ** Qed
| |
skyscraperPresheaf_eq_pushforward ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{w, v} C inst✝ : HasTerminal C A : C hd : (U : Opens ↑(of PUnit.{u + 1})) → Decidable (PUnit.unit ∈ U) ⊢ skyscraperPresheaf p₀ A = ContinuousMap.const (↑(of PUnit.{u + 1})) p₀ _* skyscraperPresheaf PUnit.unit A ** convert_to @skyscraperPresheaf X p₀ (fun U => hd <| (Opens.map <| ContinuousMap.const _ p₀).obj U)
C _ _ A = _ <;> congr ** Qed
| |
SkyscraperPresheafFunctor.map'_id ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{w, v} C inst✝ : HasTerminal C A a : C ⊢ map' p₀ (𝟙 a) = 𝟙 (skyscraperPresheaf p₀ a) ** refine NatTrans.ext _ _ <| funext fun U => ?_ ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{w, v} C inst✝ : HasTerminal C A a : C U : (Opens ↑X)ᵒᵖ ⊢ (map' p₀ (𝟙 a)).app U = (𝟙 (skyscraperPresheaf p₀ a)).app U ** simp only [SkyscraperPresheafFunctor.map'_app, NatTrans.id_app] ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{w, v} C inst✝ : HasTerminal C A a : C U : (Opens ↑X)ᵒᵖ ⊢ (if h : p₀ ∈ U.unop then eqToHom (_ : (if p₀ ∈ U.unop then a else ⊤_ C) = a) ≫ 𝟙 a ≫ eqToHom (_ : a = if p₀ ∈ U.unop then a else ⊤_ C) else IsTerminal.from ((_ : (⊤_ C) = if p₀ ∈ U.unop then a else ⊤_ C) ▸ terminalIsTerminal) ((skyscraperPresheaf p₀ a).obj U)) = (𝟙 (skyscraperPresheaf p₀ a)).app U ** split_ifs <;> aesop_cat ** Qed
| |
SkyscraperPresheafFunctor.map'_comp ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{w, v} C inst✝ : HasTerminal C A a b c : C f : a ⟶ b g : b ⟶ c ⊢ map' p₀ (f ≫ g) = map' p₀ f ≫ map' p₀ g ** refine NatTrans.ext _ _ <| funext fun U => ?_ ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{w, v} C inst✝ : HasTerminal C A a b c : C f : a ⟶ b g : b ⟶ c U : (Opens ↑X)ᵒᵖ ⊢ (map' p₀ (f ≫ g)).app U = (map' p₀ f ≫ map' p₀ g).app U ** rw [NatTrans.comp_app] ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{w, v} C inst✝ : HasTerminal C A a b c : C f : a ⟶ b g : b ⟶ c U : (Opens ↑X)ᵒᵖ ⊢ (map' p₀ (f ≫ g)).app U = (map' p₀ f).app U ≫ (map' p₀ g).app U ** simp only [SkyscraperPresheafFunctor.map'_app] ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{w, v} C inst✝ : HasTerminal C A a b c : C f : a ⟶ b g : b ⟶ c U : (Opens ↑X)ᵒᵖ ⊢ (if h : p₀ ∈ U.unop then eqToHom (_ : (if p₀ ∈ U.unop then a else ⊤_ C) = a) ≫ (f ≫ g) ≫ eqToHom (_ : c = if p₀ ∈ U.unop then c else ⊤_ C) else IsTerminal.from ((_ : (⊤_ C) = if p₀ ∈ U.unop then c else ⊤_ C) ▸ terminalIsTerminal) ((skyscraperPresheaf p₀ a).obj U)) = (if h : p₀ ∈ U.unop then eqToHom (_ : (if p₀ ∈ U.unop then a else ⊤_ C) = a) ≫ f ≫ eqToHom (_ : b = if p₀ ∈ U.unop then b else ⊤_ C) else IsTerminal.from ((_ : (⊤_ C) = if p₀ ∈ U.unop then b else ⊤_ C) ▸ terminalIsTerminal) ((skyscraperPresheaf p₀ a).obj U)) ≫ if h : p₀ ∈ U.unop then eqToHom (_ : (if p₀ ∈ U.unop then b else ⊤_ C) = b) ≫ g ≫ eqToHom (_ : c = if p₀ ∈ U.unop then c else ⊤_ C) else IsTerminal.from ((_ : (⊤_ C) = if p₀ ∈ U.unop then c else ⊤_ C) ▸ terminalIsTerminal) ((skyscraperPresheaf p₀ b).obj U) ** split_ifs with h <;> aesop_cat ** Qed
| |
skyscraperPresheaf_isSheaf ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{u, v} C A : C inst✝ : HasTerminal C ⊢ IsTerminal ((skyscraperPresheaf PUnit.unit A).obj (op ⊥)) ** dsimp [skyscraperPresheaf] ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{u, v} C A : C inst✝ : HasTerminal C ⊢ IsTerminal (if PUnit.unit ∈ ⊥ then A else ⊤_ C) ** rw [if_neg] ** X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{u, v} C A : C inst✝ : HasTerminal C ⊢ IsTerminal (⊤_ C) ** exact terminalIsTerminal ** case hnc X : TopCat p₀ : ↑X inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝¹ : Category.{u, v} C A : C inst✝ : HasTerminal C ⊢ ¬PUnit.unit ∈ ⊥ ** exact Set.not_mem_empty PUnit.unit ** Qed
| |
StalkSkyscraperPresheafAdjunctionAuxs.to_skyscraper_fromStalk ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : 𝓕 ⟶ skyscraperPresheaf p₀ c U : (Opens ↑X)ᵒᵖ h : p₀ ∈ U.unop ⊢ (toSkyscraperPresheaf p₀ (fromStalk p₀ f)).app U = f.app U ** dsimp ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : 𝓕 ⟶ skyscraperPresheaf p₀ c U : (Opens ↑X)ᵒᵖ h : p₀ ∈ U.unop ⊢ (if h : p₀ ∈ U.unop then Presheaf.germ 𝓕 { val := p₀, property := h } ≫ fromStalk p₀ f ≫ eqToHom (_ : c = if p₀ ∈ U.unop then c else ⊤_ C) else IsTerminal.from ((_ : (⊤_ C) = if p₀ ∈ U.unop then c else ⊤_ C) ▸ terminalIsTerminal) (𝓕.obj U)) = f.app U ** split_ifs ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : 𝓕 ⟶ skyscraperPresheaf p₀ c U : (Opens ↑X)ᵒᵖ h : p₀ ∈ U.unop ⊢ Presheaf.germ 𝓕 { val := p₀, property := h } ≫ fromStalk p₀ f ≫ eqToHom (_ : c = if p₀ ∈ U.unop then c else ⊤_ C) = f.app U ** erw [← Category.assoc, colimit.ι_desc, Category.assoc, eqToHom_trans, eqToHom_refl,
Category.comp_id] ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : 𝓕 ⟶ skyscraperPresheaf p₀ c U : (Opens ↑X)ᵒᵖ h : p₀ ∈ U.unop ⊢ f.app (op (op { obj := U.unop, property := (_ : ↑{ val := p₀, property := h } ∈ U.unop) }).unop.obj) = f.app U ** rfl ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : 𝓕 ⟶ skyscraperPresheaf p₀ c U : (Opens ↑X)ᵒᵖ h : ¬p₀ ∈ U.unop ⊢ (toSkyscraperPresheaf p₀ (fromStalk p₀ f)).app U = f.app U ** dsimp ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : 𝓕 ⟶ skyscraperPresheaf p₀ c U : (Opens ↑X)ᵒᵖ h : ¬p₀ ∈ U.unop ⊢ (if h : p₀ ∈ U.unop then Presheaf.germ 𝓕 { val := p₀, property := h } ≫ fromStalk p₀ f ≫ eqToHom (_ : c = if p₀ ∈ U.unop then c else ⊤_ C) else IsTerminal.from ((_ : (⊤_ C) = if p₀ ∈ U.unop then c else ⊤_ C) ▸ terminalIsTerminal) (𝓕.obj U)) = f.app U ** split_ifs ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : 𝓕 ⟶ skyscraperPresheaf p₀ c U : (Opens ↑X)ᵒᵖ h : ¬p₀ ∈ U.unop ⊢ IsTerminal.from ((_ : (⊤_ C) = if p₀ ∈ U.unop then c else ⊤_ C) ▸ terminalIsTerminal) (𝓕.obj U) = f.app U ** apply ((if_neg h).symm.ndrec terminalIsTerminal).hom_ext ** Qed
| |
StalkSkyscraperPresheafAdjunctionAuxs.fromStalk_to_skyscraper ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : Presheaf.stalk 𝓕 p₀ ⟶ c U : (OpenNhds p₀)ᵒᵖ ⊢ colimit.ι (((whiskeringLeft (OpenNhds p₀)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion p₀).op).obj 𝓕) U ≫ fromStalk p₀ (toSkyscraperPresheaf p₀ f) = colimit.ι (((whiskeringLeft (OpenNhds p₀)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion p₀).op).obj 𝓕) U ≫ f ** erw [colimit.ι_desc] ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : Presheaf.stalk 𝓕 p₀ ⟶ c U : (OpenNhds p₀)ᵒᵖ ⊢ { pt := c, ι := NatTrans.mk fun U => (toSkyscraperPresheaf p₀ f).app (op U.unop.obj) ≫ eqToHom (_ : (if p₀ ∈ U.unop.obj then c else ⊤_ C) = c) }.ι.app U = colimit.ι (((whiskeringLeft (OpenNhds p₀)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion p₀).op).obj 𝓕) U ≫ f ** dsimp ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : Presheaf.stalk 𝓕 p₀ ⟶ c U : (OpenNhds p₀)ᵒᵖ ⊢ (if h : p₀ ∈ U.unop.obj then Presheaf.germ 𝓕 { val := p₀, property := h } ≫ f ≫ eqToHom (_ : c = if p₀ ∈ (op U.unop.obj).unop then c else ⊤_ C) else IsTerminal.from ((_ : (⊤_ C) = if p₀ ∈ (op U.unop.obj).unop then c else ⊤_ C) ▸ terminalIsTerminal) (𝓕.obj (op U.unop.obj))) ≫ eqToHom (_ : (if p₀ ∈ U.unop.obj then c else ⊤_ C) = c) = colimit.ι ((OpenNhds.inclusion p₀).op ⋙ 𝓕) U ≫ f ** rw [dif_pos U.unop.2] ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : Presheaf.stalk 𝓕 p₀ ⟶ c U : (OpenNhds p₀)ᵒᵖ ⊢ (Presheaf.germ 𝓕 { val := p₀, property := (_ : p₀ ∈ U.unop.obj) } ≫ f ≫ eqToHom (_ : c = if p₀ ∈ (op U.unop.obj).unop then c else ⊤_ C)) ≫ eqToHom (_ : (if p₀ ∈ U.unop.obj then c else ⊤_ C) = c) = colimit.ι ((OpenNhds.inclusion p₀).op ⋙ 𝓕) U ≫ f ** rw [Category.assoc, Category.assoc, eqToHom_trans, eqToHom_refl, Category.comp_id,
Presheaf.germ] ** X : TopCat p₀ : ↑X inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U) C : Type v inst✝² : Category.{u, v} C A : C inst✝¹ : HasTerminal C inst✝ : HasColimits C 𝓕 : Presheaf C X c : C f : Presheaf.stalk 𝓕 p₀ ⟶ c U : (OpenNhds p₀)ᵒᵖ ⊢ colimit.ι ((OpenNhds.inclusion ↑{ val := p₀, property := (_ : p₀ ∈ U.unop.obj) }).op ⋙ 𝓕) (op { obj := U.unop.obj, property := (_ : ↑{ val := p₀, property := (_ : p₀ ∈ U.unop.obj) } ∈ U.unop.obj) }) ≫ f = colimit.ι ((OpenNhds.inclusion p₀).op ⋙ 𝓕) U ≫ f ** congr 3 ** Qed
| |
Ordinal.toPGame_def ** o : Ordinal.{u_1} ⊢ let_fun this := (_ : IsWellOrder (Quotient.out o).α fun x x_1 => x < x_1); toPGame o = mk (Quotient.out o).α PEmpty.{u_1 + 1} (fun x => toPGame (typein (fun x x_1 => x < x_1) x)) PEmpty.elim ** rw [toPGame] ** Qed
| |
Ordinal.toPGame_leftMoves ** o : Ordinal.{u_1} ⊢ LeftMoves (toPGame o) = (Quotient.out o).α ** rw [toPGame, LeftMoves] ** Qed
| |
Ordinal.toPGame_rightMoves ** o : Ordinal.{u_1} ⊢ RightMoves (toPGame o) = PEmpty.{u_1 + 1} ** rw [toPGame, RightMoves] ** Qed
| |
Ordinal.toPGame_moveLeft_hEq ** o : Ordinal.{u_1} ⊢ let_fun this := (_ : IsWellOrder (Quotient.out o).α fun x x_1 => x < x_1); HEq (moveLeft (toPGame o)) fun x => toPGame (typein (fun x x_1 => x < x_1) x) ** rw [toPGame] ** o : Ordinal.{u_1} ⊢ let_fun this := (_ : IsWellOrder (Quotient.out o).α fun x x_1 => x < x_1); HEq (moveLeft ((fun this => mk (Quotient.out o).α PEmpty.{u_1 + 1} (fun x => let_fun this_1 := (_ : typein (fun x x_1 => x < x_1) x < o); toPGame (typein (fun x x_1 => x < x_1) x)) PEmpty.elim) (_ : IsWellOrder (Quotient.out o).α fun x x_1 => x < x_1))) fun x => toPGame (typein (fun x x_1 => x < x_1) x) ** rfl ** Qed
| |
Ordinal.toPGame_moveLeft ** o : Ordinal.{u_1} i : ↑(Set.Iio o) ⊢ moveLeft (toPGame o) (↑toLeftMovesToPGame i) = toPGame ↑i ** simp ** Qed
| |
Ordinal.to_leftMoves_one_toPGame_symm ** i : LeftMoves (toPGame 1) ⊢ ↑toLeftMovesToPGame.symm i = { val := 0, property := (_ : 0 ∈ Set.Iio 1) } ** simp ** Qed
| |
Ordinal.one_toPGame_moveLeft ** x : LeftMoves (toPGame 1) ⊢ moveLeft (toPGame 1) x = toPGame 0 ** simp ** Qed
| |
Ordinal.toPGame_lf ** a b : Ordinal.{u_1} h : a < b ⊢ toPGame a ⧏ toPGame b ** convert moveLeft_lf (toLeftMovesToPGame ⟨a, h⟩) ** case h.e'_1 a b : Ordinal.{u_1} h : a < b ⊢ toPGame a = moveLeft (toPGame b) (↑toLeftMovesToPGame { val := a, property := h }) ** rw [toPGame_moveLeft] ** Qed
| |
Ordinal.toPGame_le ** a b : Ordinal.{u_1} h : a ≤ b ⊢ toPGame a ≤ toPGame b ** refine' le_iff_forall_lf.2 ⟨fun i => _, isEmptyElim⟩ ** a b : Ordinal.{u_1} h : a ≤ b i : LeftMoves (toPGame a) ⊢ moveLeft (toPGame a) i ⧏ toPGame b ** rw [toPGame_moveLeft'] ** a b : Ordinal.{u_1} h : a ≤ b i : LeftMoves (toPGame a) ⊢ toPGame ↑(↑toLeftMovesToPGame.symm i) ⧏ toPGame b ** exact toPGame_lf ((toLeftMovesToPGame_symm_lt i).trans_le h) ** Qed
| |
Ordinal.toPGame_lf_iff ** a b : Ordinal.{u_1} ⊢ toPGame a ⧏ toPGame b → a < b ** contrapose ** a b : Ordinal.{u_1} ⊢ ¬a < b → ¬toPGame a ⧏ toPGame b ** rw [not_lt, not_lf] ** a b : Ordinal.{u_1} ⊢ b ≤ a → toPGame b ≤ toPGame a ** exact toPGame_le ** Qed
| |
Ordinal.toPGame_le_iff ** a b : Ordinal.{u_1} ⊢ toPGame a ≤ toPGame b → a ≤ b ** contrapose ** a b : Ordinal.{u_1} ⊢ ¬a ≤ b → ¬toPGame a ≤ toPGame b ** rw [not_le, PGame.not_le] ** a b : Ordinal.{u_1} ⊢ b < a → toPGame b ⧏ toPGame a ** exact toPGame_lf ** Qed
| |
Ordinal.toPGame_lt_iff ** a b : Ordinal.{u_1} ⊢ toPGame a < toPGame b → a < b ** contrapose ** a b : Ordinal.{u_1} ⊢ ¬a < b → ¬toPGame a < toPGame b ** rw [not_lt] ** a b : Ordinal.{u_1} ⊢ b ≤ a → ¬toPGame a < toPGame b ** exact fun h => not_lt_of_le (toPGame_le h) ** Qed
| |
Ordinal.toPGame_equiv_iff ** a b : Ordinal.{u_1} ⊢ toPGame a ≈ toPGame b ↔ a = b ** change _ ≤_ ∧ _ ≤ _ ↔ _ ** a b : Ordinal.{u_1} ⊢ toPGame a ≤ toPGame b ∧ toPGame b ≤ toPGame a ↔ a = b ** rw [le_antisymm_iff, toPGame_le_iff, toPGame_le_iff] ** Qed
| |
Ordinal.toPGame_add ** a b : Ordinal.{u} ⊢ toPGame a + toPGame b ≈ toPGame (a ♯ b) ** refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩ ** case refine'_1 a b : Ordinal.{u} i : LeftMoves (toPGame a + toPGame b) ⊢ moveLeft (toPGame a + toPGame b) i ⧏ toPGame (a ♯ b) ** apply leftMoves_add_cases i <;>
intro i <;>
let wf := toLeftMovesToPGame_symm_lt i <;>
(try rw [add_moveLeft_inl]) <;>
(try rw [add_moveLeft_inr]) <;>
rw [toPGame_moveLeft', lf_congr_left (toPGame_add _ _), toPGame_lf_iff] ** case refine'_1.hl a b : Ordinal.{u} i✝ : LeftMoves (toPGame a + toPGame b) i : LeftMoves (toPGame a) wf : ↑(↑toLeftMovesToPGame.symm i) < a := toLeftMovesToPGame_symm_lt i ⊢ moveLeft (toPGame a + toPGame b) (↑toLeftMovesAdd (Sum.inl i)) ⧏ toPGame (a ♯ b) ** try rw [add_moveLeft_inl] ** case refine'_1.hl a b : Ordinal.{u} i✝ : LeftMoves (toPGame a + toPGame b) i : LeftMoves (toPGame a) wf : ↑(↑toLeftMovesToPGame.symm i) < a := toLeftMovesToPGame_symm_lt i ⊢ moveLeft (toPGame a + toPGame b) (↑toLeftMovesAdd (Sum.inl i)) ⧏ toPGame (a ♯ b) ** rw [add_moveLeft_inl] ** case refine'_1.hr a b : Ordinal.{u} i✝ : LeftMoves (toPGame a + toPGame b) i : LeftMoves (toPGame b) wf : ↑(↑toLeftMovesToPGame.symm i) < b := toLeftMovesToPGame_symm_lt i ⊢ moveLeft (toPGame a + toPGame b) (↑toLeftMovesAdd (Sum.inr i)) ⧏ toPGame (a ♯ b) ** try rw [add_moveLeft_inr] ** case refine'_1.hr a b : Ordinal.{u} i✝ : LeftMoves (toPGame a + toPGame b) i : LeftMoves (toPGame b) wf : ↑(↑toLeftMovesToPGame.symm i) < b := toLeftMovesToPGame_symm_lt i ⊢ moveLeft (toPGame a + toPGame b) (↑toLeftMovesAdd (Sum.inr i)) ⧏ toPGame (a ♯ b) ** rw [add_moveLeft_inr] ** case refine'_1.hl a b : Ordinal.{u} i✝ : LeftMoves (toPGame a + toPGame b) i : LeftMoves (toPGame a) wf : ↑(↑toLeftMovesToPGame.symm i) < a := toLeftMovesToPGame_symm_lt i ⊢ ↑(↑toLeftMovesToPGame.symm i) ♯ b < a ♯ b ** exact nadd_lt_nadd_right wf _ ** case refine'_1.hr a b : Ordinal.{u} i✝ : LeftMoves (toPGame a + toPGame b) i : LeftMoves (toPGame b) wf : ↑(↑toLeftMovesToPGame.symm i) < b := toLeftMovesToPGame_symm_lt i ⊢ a ♯ ↑(↑toLeftMovesToPGame.symm i) < a ♯ b ** exact nadd_lt_nadd_left wf _ ** case refine'_2 a b : Ordinal.{u} i : LeftMoves (toPGame (a ♯ b)) ⊢ moveLeft (toPGame (a ♯ b)) i ⧏ toPGame a + toPGame b ** rw [toPGame_moveLeft'] ** case refine'_2 a b : Ordinal.{u} i : LeftMoves (toPGame (a ♯ b)) ⊢ toPGame ↑(↑toLeftMovesToPGame.symm i) ⧏ toPGame a + toPGame b ** rcases lt_nadd_iff.1 (toLeftMovesToPGame_symm_lt i) with (⟨c, hc, hc'⟩ | ⟨c, hc, hc'⟩) <;>
rw [← toPGame_le_iff, ← le_congr_right (toPGame_add _ _)] at hc' <;>
apply lf_of_le_of_lf hc' ** case refine'_2.inl.intro.intro a b : Ordinal.{u} i : LeftMoves (toPGame (a ♯ b)) c : Ordinal.{u} hc : c < a hc' : toPGame ↑(↑toLeftMovesToPGame.symm i) ≤ toPGame c + toPGame b ⊢ toPGame c + toPGame b ⧏ toPGame a + toPGame b ** apply add_lf_add_right ** case refine'_2.inl.intro.intro.h a b : Ordinal.{u} i : LeftMoves (toPGame (a ♯ b)) c : Ordinal.{u} hc : c < a hc' : toPGame ↑(↑toLeftMovesToPGame.symm i) ≤ toPGame c + toPGame b ⊢ toPGame c ⧏ toPGame a ** rwa [toPGame_lf_iff] ** case refine'_2.inr.intro.intro a b : Ordinal.{u} i : LeftMoves (toPGame (a ♯ b)) c : Ordinal.{u} hc : c < b hc' : toPGame ↑(↑toLeftMovesToPGame.symm i) ≤ toPGame a + toPGame c ⊢ toPGame a + toPGame c ⧏ toPGame a + toPGame b ** apply add_lf_add_left ** case refine'_2.inr.intro.intro.h a b : Ordinal.{u} i : LeftMoves (toPGame (a ♯ b)) c : Ordinal.{u} hc : c < b hc' : toPGame ↑(↑toLeftMovesToPGame.symm i) ≤ toPGame a + toPGame c ⊢ toPGame c ⧏ toPGame b ** rwa [toPGame_lf_iff] ** Qed
| |
SetTheory.PGame.powHalf_leftMoves ** n : ℕ ⊢ LeftMoves (powHalf n) = PUnit.{u_1 + 1} ** cases n <;> rfl ** Qed
| |
SetTheory.PGame.powHalf_moveLeft ** n : ℕ i : LeftMoves (powHalf n) ⊢ moveLeft (powHalf n) i = 0 ** cases n <;> cases i <;> rfl ** Qed
| |
SetTheory.PGame.birthday_half ** ⊢ birthday (powHalf 1) = 2 ** rw [birthday_def] ** ⊢ max (Ordinal.lsub fun i => birthday (moveLeft (powHalf 1) i)) (Ordinal.lsub fun i => birthday (moveRight (powHalf 1) i)) = 2 ** dsimp ** ⊢ max (Ordinal.lsub fun i => birthday (moveLeft (powHalf 1) i)) (Ordinal.lsub fun i => birthday 1) = 2 ** simpa using Order.le_succ (1 : Ordinal) ** Qed
| |
SetTheory.PGame.numeric_powHalf ** n : ℕ ⊢ Numeric (powHalf n) ** induction' n with n hn ** case zero ⊢ Numeric (powHalf Nat.zero) ** exact numeric_one ** case succ n : ℕ hn : Numeric (powHalf n) ⊢ Numeric (powHalf (Nat.succ n)) ** constructor ** case succ.left n : ℕ hn : Numeric (powHalf n) ⊢ ∀ (i j : PUnit.{u_1 + 1}), OfNat.ofNat 0 i < (fun x => powHalf n) j ** simpa using hn.moveLeft_lt default ** case succ.right n : ℕ hn : Numeric (powHalf n) ⊢ (∀ (i : PUnit.{u_1 + 1}), Numeric (OfNat.ofNat 0 i)) ∧ ∀ (j : PUnit.{u_1 + 1}), Numeric ((fun x => powHalf n) j) ** exact ⟨fun _ => numeric_zero, fun _ => hn⟩ ** Qed
| |
SetTheory.PGame.powHalf_le_one ** n : ℕ ⊢ powHalf n ≤ 1 ** induction' n with n hn ** case zero ⊢ powHalf Nat.zero ≤ 1 ** exact le_rfl ** case succ n : ℕ hn : powHalf n ≤ 1 ⊢ powHalf (Nat.succ n) ≤ 1 ** exact (powHalf_succ_le_powHalf n).trans hn ** Qed
| |
SetTheory.PGame.powHalf_pos ** n : ℕ ⊢ 0 < powHalf n ** rw [← lf_iff_lt numeric_zero (numeric_powHalf n), zero_lf_le] ** n : ℕ ⊢ ∃ i, 0 ≤ moveLeft (powHalf n) i ** simp ** Qed
| |
SetTheory.PGame.add_powHalf_succ_self_eq_powHalf ** n : ℕ ⊢ powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n ** induction' n using Nat.strong_induction_on with n hn ** case h n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n ** constructor <;> rw [le_iff_forall_lf] <;> constructor ** case h.left.left n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ ∀ (i : LeftMoves (powHalf (n + 1) + powHalf (n + 1))), moveLeft (powHalf (n + 1) + powHalf (n + 1)) i ⧏ powHalf n ** rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt ** case h.left.left.inl.unit.h n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ moveLeft (powHalf (n + 1) + powHalf (n + 1)) (Sum.inl PUnit.unit) < powHalf n ** calc
0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
_ < powHalf n := powHalf_succ_lt_powHalf n ** case h.left.left.inr.unit.h n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ moveLeft (powHalf (n + 1) + powHalf (n + 1)) (Sum.inr PUnit.unit) < powHalf n ** calc
powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
_ < powHalf n := powHalf_succ_lt_powHalf n ** case h.left.right n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ ∀ (j : RightMoves (powHalf n)), powHalf (n + 1) + powHalf (n + 1) ⧏ moveRight (powHalf n) j ** cases' n with n ** case h.left.right.succ n : ℕ hn : ∀ (m : ℕ), m < Nat.succ n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ ∀ (j : RightMoves (powHalf (Nat.succ n))), powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1) ⧏ moveRight (powHalf (Nat.succ n)) j ** rintro ⟨⟩ ** case h.left.right.succ.unit n : ℕ hn : ∀ (m : ℕ), m < Nat.succ n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1) ⧏ moveRight (powHalf (Nat.succ n)) PUnit.unit ** apply lf_of_moveRight_le ** case h.left.right.succ.unit.h n : ℕ hn : ∀ (m : ℕ), m < Nat.succ n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ moveRight (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1)) ?h.left.right.succ.unit.j ≤ moveRight (powHalf (Nat.succ n)) PUnit.unit case h.left.right.succ.unit.j n : ℕ hn : ∀ (m : ℕ), m < Nat.succ n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ RightMoves (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1)) ** swap ** case h.left.right.succ.unit.j n : ℕ hn : ∀ (m : ℕ), m < Nat.succ n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ RightMoves (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1)) case h.left.right.succ.unit.h n : ℕ hn : ∀ (m : ℕ), m < Nat.succ n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ moveRight (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1)) ?h.left.right.succ.unit.j ≤ moveRight (powHalf (Nat.succ n)) PUnit.unit ** exact Sum.inl default ** case h.left.right.succ.unit.h n : ℕ hn : ∀ (m : ℕ), m < Nat.succ n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ moveRight (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1)) (Sum.inl default) ≤ moveRight (powHalf (Nat.succ n)) PUnit.unit ** calc
powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
add_le_add_left (powHalf_succ_le_powHalf _) _
_ ≈ powHalf n := hn _ (Nat.lt_succ_self n) ** case h.left.right.zero hn : ∀ (m : ℕ), m < Nat.zero → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ ∀ (j : RightMoves (powHalf Nat.zero)), powHalf (Nat.zero + 1) + powHalf (Nat.zero + 1) ⧏ moveRight (powHalf Nat.zero) j ** rintro ⟨⟩ ** case h.right.left n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ ∀ (i : LeftMoves (powHalf n)), moveLeft (powHalf n) i ⧏ powHalf (n + 1) + powHalf (n + 1) ** simp only [powHalf_moveLeft, forall_const] ** case h.right.left n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ 0 ⧏ powHalf (n + 1) + powHalf (n + 1) ** apply lf_of_lt ** case h.right.left.h n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ 0 < powHalf (n + 1) + powHalf (n + 1) ** calc
0 ≈ 0 + 0 := (Equiv.symm (add_zero_equiv 0))
_ ≤ powHalf n.succ + 0 := (add_le_add_right (zero_le_powHalf _) _)
_ < powHalf n.succ + powHalf n.succ := add_lt_add_left (powHalf_pos _) _ ** case h.right.right n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ ∀ (j : RightMoves (powHalf (n + 1) + powHalf (n + 1))), powHalf n ⧏ moveRight (powHalf (n + 1) + powHalf (n + 1)) j ** rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt ** case h.right.right.inl.unit.h n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ powHalf n < moveRight (powHalf (n + 1) + powHalf (n + 1)) (Sum.inl PUnit.unit) ** calc
powHalf n ≈ powHalf n + 0 := (Equiv.symm (add_zero_equiv _))
_ < powHalf n + powHalf n.succ := add_lt_add_left (powHalf_pos _) _ ** case h.right.right.inr.unit.h n : ℕ hn : ∀ (m : ℕ), m < n → powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m ⊢ powHalf n < moveRight (powHalf (n + 1) + powHalf (n + 1)) (Sum.inr PUnit.unit) ** calc
powHalf n ≈ 0 + powHalf n := (Equiv.symm (zero_add_equiv _))
_ < powHalf n.succ + powHalf n := add_lt_add_right (powHalf_pos _) _ ** Qed
| |
Surreal.double_powHalf_succ_eq_powHalf ** n : ℕ ⊢ 2 • powHalf (Nat.succ n) = powHalf n ** rw [two_nsmul] ** n : ℕ ⊢ powHalf (Nat.succ n) + powHalf (Nat.succ n) = powHalf n ** exact Quotient.sound (PGame.add_powHalf_succ_self_eq_powHalf n) ** Qed
| |
Surreal.nsmul_pow_two_powHalf ** n : ℕ ⊢ 2 ^ n • powHalf n = 1 ** induction' n with n hn ** case zero ⊢ 2 ^ Nat.zero • powHalf Nat.zero = 1 ** simp only [Nat.zero_eq, pow_zero, powHalf_zero, one_smul] ** case succ n : ℕ hn : 2 ^ n • powHalf n = 1 ⊢ 2 ^ Nat.succ n • powHalf (Nat.succ n) = 1 ** rw [← hn, ← double_powHalf_succ_eq_powHalf n, smul_smul (2 ^ n) 2 (powHalf n.succ), mul_comm,
pow_succ] ** Qed
| |
Surreal.nsmul_pow_two_powHalf' ** n k : ℕ ⊢ 2 ^ n • powHalf (n + k) = powHalf k ** induction' k with k hk ** case zero n : ℕ ⊢ 2 ^ n • powHalf (n + Nat.zero) = powHalf Nat.zero ** simp only [add_zero, Surreal.nsmul_pow_two_powHalf, Nat.zero_eq, eq_self_iff_true,
Surreal.powHalf_zero] ** case succ n k : ℕ hk : 2 ^ n • powHalf (n + k) = powHalf k ⊢ 2 ^ n • powHalf (n + Nat.succ k) = powHalf (Nat.succ k) ** rw [← double_powHalf_succ_eq_powHalf (n + k), ← double_powHalf_succ_eq_powHalf k,
smul_algebra_smul_comm] at hk ** case succ n k : ℕ hk : 2 • 2 ^ n • powHalf (Nat.succ (n + k)) = 2 • powHalf (Nat.succ k) ⊢ 2 ^ n • powHalf (n + Nat.succ k) = powHalf (Nat.succ k) ** rwa [← zsmul_eq_zsmul_iff' two_ne_zero] ** Qed
| |
Surreal.zsmul_pow_two_powHalf ** m : ℤ n k : ℕ ⊢ (m * 2 ^ n) • powHalf (n + k) = m • powHalf k ** rw [mul_zsmul] ** m : ℤ n k : ℕ ⊢ m • 2 ^ n • powHalf (n + k) = m • powHalf k ** congr ** case e_a m : ℤ n k : ℕ ⊢ 2 ^ n • powHalf (n + k) = powHalf k ** exact nsmul_pow_two_powHalf' n k ** Qed
| |
Surreal.dyadic_aux ** m₁ m₂ : ℤ y₁ y₂ : ℕ h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ ⊢ m₁ • powHalf y₂ = m₂ • powHalf y₁ ** revert m₁ m₂ ** y₁ y₂ : ℕ ⊢ ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → m₁ • powHalf y₂ = m₂ • powHalf y₁ ** wlog h : y₁ ≤ y₂ ** y₁ y₂ : ℕ h : y₁ ≤ y₂ ⊢ ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → m₁ • powHalf y₂ = m₂ • powHalf y₁ ** intro m₁ m₂ h₂ ** y₁ y₂ : ℕ h : y₁ ≤ y₂ m₁ m₂ : ℤ h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ ⊢ m₁ • powHalf y₂ = m₂ • powHalf y₁ ** obtain ⟨c, rfl⟩ := le_iff_exists_add.mp h ** case intro y₁ : ℕ m₁ m₂ : ℤ c : ℕ h : y₁ ≤ y₁ + c h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ (y₁ + c) ⊢ m₁ • powHalf (y₁ + c) = m₂ • powHalf y₁ ** rw [add_comm, pow_add, ← mul_assoc, mul_eq_mul_right_iff] at h₂ ** case intro y₁ : ℕ m₁ m₂ : ℤ c : ℕ h : y₁ ≤ y₁ + c h₂ : m₁ = m₂ * 2 ^ c ∨ 2 ^ y₁ = 0 ⊢ m₁ • powHalf (y₁ + c) = m₂ • powHalf y₁ ** cases' h₂ with h₂ h₂ ** case inr y₁ y₂ : ℕ this : ∀ {y₁ y₂ : ℕ}, y₁ ≤ y₂ → ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → m₁ • powHalf y₂ = m₂ • powHalf y₁ h : ¬y₁ ≤ y₂ ⊢ ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → m₁ • powHalf y₂ = m₂ • powHalf y₁ ** intro m₁ m₂ aux ** case inr y₁ y₂ : ℕ this : ∀ {y₁ y₂ : ℕ}, y₁ ≤ y₂ → ∀ {m₁ m₂ : ℤ}, m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ → m₁ • powHalf y₂ = m₂ • powHalf y₁ h : ¬y₁ ≤ y₂ m₁ m₂ : ℤ aux : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂ ⊢ m₁ • powHalf y₂ = m₂ • powHalf y₁ ** exact (this (le_of_not_le h) aux.symm).symm ** case intro.inl y₁ : ℕ m₁ m₂ : ℤ c : ℕ h : y₁ ≤ y₁ + c h₂ : m₁ = m₂ * 2 ^ c ⊢ m₁ • powHalf (y₁ + c) = m₂ • powHalf y₁ ** rw [h₂, add_comm, zsmul_pow_two_powHalf m₂ c y₁] ** case intro.inr y₁ : ℕ m₁ m₂ : ℤ c : ℕ h : y₁ ≤ y₁ + c h₂ : 2 ^ y₁ = 0 ⊢ m₁ • powHalf (y₁ + c) = m₂ • powHalf y₁ ** have := Nat.one_le_pow y₁ 2 Nat.succ_pos' ** case intro.inr y₁ : ℕ m₁ m₂ : ℤ c : ℕ h : y₁ ≤ y₁ + c h₂ : 2 ^ y₁ = 0 this : 1 ≤ 2 ^ y₁ ⊢ m₁ • powHalf (y₁ + c) = m₂ • powHalf y₁ ** norm_cast at h₂ ** case intro.inr y₁ : ℕ m₁ m₂ : ℤ c : ℕ h : y₁ ≤ y₁ + c this : 1 ≤ 2 ^ y₁ h₂ : 2 ^ y₁ = 0 ⊢ m₁ • powHalf (y₁ + c) = m₂ • powHalf y₁ ** linarith ** Qed
| |
Surreal.dyadicMap_apply ** m : ℤ p : { x // x ∈ Submonoid.powers 2 } ⊢ ↑dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m p) = m • powHalf (Submonoid.log p) ** rw [← Localization.mk_eq_mk'] ** m : ℤ p : { x // x ∈ Submonoid.powers 2 } ⊢ ↑dyadicMap (Localization.mk m p) = m • powHalf (Submonoid.log p) ** rfl ** Qed
| |
Surreal.dyadicMap_apply_pow ** m : ℤ n : ℕ ⊢ ↑dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m (Submonoid.pow 2 n)) = m • powHalf n ** rw [dyadicMap_apply, @Submonoid.log_pow_int_eq_self 2 one_lt_two] ** Qed
| |
Surreal.dyadicMap_apply_pow' ** m : ℤ n : ℕ ⊢ m • powHalf (Submonoid.log (Submonoid.pow 2 n)) = m • powHalf n ** rw [@Submonoid.log_pow_int_eq_self 2 one_lt_two] ** Qed
| |
Ordinal.zero_opow' ** a : Ordinal.{u_1} ⊢ 0 ^ a = 1 - a ** simp only [opow_def, if_true] ** Qed
| |
Ordinal.zero_opow ** a : Ordinal.{u_1} a0 : a ≠ 0 ⊢ 0 ^ a = 0 ** rwa [zero_opow', Ordinal.sub_eq_zero_iff_le, one_le_iff_ne_zero] ** Qed
| |
Ordinal.opow_zero ** a : Ordinal.{u_1} ⊢ a ^ 0 = 1 ** by_cases h : a = 0 ** case pos a : Ordinal.{u_1} h : a = 0 ⊢ a ^ 0 = 1 ** simp only [opow_def, if_pos h, sub_zero] ** case neg a : Ordinal.{u_1} h : ¬a = 0 ⊢ a ^ 0 = 1 ** simp only [opow_def, if_neg h, limitRecOn_zero] ** Qed
| |
Ordinal.opow_succ ** a b : Ordinal.{u_1} h : a = 0 ⊢ a ^ succ b = a ^ b * a ** subst a ** b : Ordinal.{u_1} ⊢ 0 ^ succ b = 0 ^ b * 0 ** simp only [zero_opow (succ_ne_zero _), mul_zero] ** a b : Ordinal.{u_1} h : ¬a = 0 ⊢ a ^ succ b = a ^ b * a ** simp only [opow_def, limitRecOn_succ, if_neg h] ** Qed
| |
Ordinal.opow_limit ** a b : Ordinal.{u} a0 : a ≠ 0 h : IsLimit b ⊢ a ^ b = bsup b fun c x => a ^ c ** simp only [opow_def, if_neg a0] ** a b : Ordinal.{u} a0 : a ≠ 0 h : IsLimit b ⊢ (limitRecOn b 1 (fun x IH => IH * a) fun b x => bsup b) = bsup b fun c x => limitRecOn c 1 (fun x IH => IH * a) fun b x => bsup b ** rw [limitRecOn_limit _ _ _ _ h] ** Qed
| |
Ordinal.opow_le_of_limit ** a b c : Ordinal.{u_1} a0 : a ≠ 0 h : IsLimit b ⊢ a ^ b ≤ c ↔ ∀ (b' : Ordinal.{u_1}), b' < b → a ^ b' ≤ c ** rw [opow_limit a0 h, bsup_le_iff] ** Qed
| |
Ordinal.lt_opow_of_limit ** a b c : Ordinal.{u_1} b0 : b ≠ 0 h : IsLimit c ⊢ a < b ^ c ↔ ∃ c', c' < c ∧ a < b ^ c' ** rw [← not_iff_not, not_exists] ** a b c : Ordinal.{u_1} b0 : b ≠ 0 h : IsLimit c ⊢ ¬a < b ^ c ↔ ∀ (x : Ordinal.{u_1}), ¬(x < c ∧ a < b ^ x) ** simp only [not_lt, opow_le_of_limit b0 h, exists_prop, not_and] ** Qed
| |
Ordinal.opow_one ** a : Ordinal.{u_1} ⊢ a ^ 1 = a ** rw [← succ_zero, opow_succ] ** a : Ordinal.{u_1} ⊢ a ^ 0 * a = a ** simp only [opow_zero, one_mul] ** Qed
| |
Ordinal.one_opow ** a : Ordinal.{u_1} ⊢ 1 ^ a = 1 ** induction a using limitRecOn with
| H₁ => simp only [opow_zero]
| H₂ _ ih =>
simp only [opow_succ, ih, mul_one]
| H₃ b l IH =>
refine' eq_of_forall_ge_iff fun c => _
rw [opow_le_of_limit Ordinal.one_ne_zero l]
exact ⟨fun H => by simpa only [opow_zero] using H 0 l.pos, fun H b' h => by rwa [IH _ h]⟩ ** case H₁ ⊢ 1 ^ 0 = 1 ** simp only [opow_zero] ** case H₂ o✝ : Ordinal.{u_1} ih : 1 ^ o✝ = 1 ⊢ 1 ^ succ o✝ = 1 ** simp only [opow_succ, ih, mul_one] ** case H₃ b : Ordinal.{u_1} l : IsLimit b IH : ∀ (o' : Ordinal.{u_1}), o' < b → 1 ^ o' = 1 ⊢ 1 ^ b = 1 ** refine' eq_of_forall_ge_iff fun c => _ ** case H₃ b : Ordinal.{u_1} l : IsLimit b IH : ∀ (o' : Ordinal.{u_1}), o' < b → 1 ^ o' = 1 c : Ordinal.{u_1} ⊢ 1 ^ b ≤ c ↔ 1 ≤ c ** rw [opow_le_of_limit Ordinal.one_ne_zero l] ** case H₃ b : Ordinal.{u_1} l : IsLimit b IH : ∀ (o' : Ordinal.{u_1}), o' < b → 1 ^ o' = 1 c : Ordinal.{u_1} ⊢ (∀ (b' : Ordinal.{u_1}), b' < b → 1 ^ b' ≤ c) ↔ 1 ≤ c ** exact ⟨fun H => by simpa only [opow_zero] using H 0 l.pos, fun H b' h => by rwa [IH _ h]⟩ ** b : Ordinal.{u_1} l : IsLimit b IH : ∀ (o' : Ordinal.{u_1}), o' < b → 1 ^ o' = 1 c : Ordinal.{u_1} H : ∀ (b' : Ordinal.{u_1}), b' < b → 1 ^ b' ≤ c ⊢ 1 ≤ c ** simpa only [opow_zero] using H 0 l.pos ** b : Ordinal.{u_1} l : IsLimit b IH : ∀ (o' : Ordinal.{u_1}), o' < b → 1 ^ o' = 1 c : Ordinal.{u_1} H : 1 ≤ c b' : Ordinal.{u_1} h : b' < b ⊢ 1 ^ b' ≤ c ** rwa [IH _ h] ** Qed
| |
Ordinal.opow_pos ** a b : Ordinal.{u_1} a0 : 0 < a ⊢ 0 < a ^ b ** have h0 : 0 < (a^0) := by simp only [opow_zero, zero_lt_one] ** a b : Ordinal.{u_1} a0 : 0 < a h0 : 0 < a ^ 0 ⊢ 0 < a ^ b ** induction b using limitRecOn with
| H₁ => exact h0
| H₂ b IH =>
rw [opow_succ]
exact mul_pos IH a0
| H₃ b l _ =>
exact (lt_opow_of_limit (Ordinal.pos_iff_ne_zero.1 a0) l).2 ⟨0, l.pos, h0⟩ ** a b : Ordinal.{u_1} a0 : 0 < a ⊢ 0 < a ^ 0 ** simp only [opow_zero, zero_lt_one] ** case H₁ a : Ordinal.{u_1} a0 : 0 < a h0 : 0 < a ^ 0 ⊢ 0 < a ^ 0 ** exact h0 ** case H₂ a : Ordinal.{u_1} a0 : 0 < a h0 : 0 < a ^ 0 b : Ordinal.{u_1} IH : 0 < a ^ b ⊢ 0 < a ^ succ b ** rw [opow_succ] ** case H₂ a : Ordinal.{u_1} a0 : 0 < a h0 : 0 < a ^ 0 b : Ordinal.{u_1} IH : 0 < a ^ b ⊢ 0 < a ^ b * a ** exact mul_pos IH a0 ** case H₃ a : Ordinal.{u_1} a0 : 0 < a h0 : 0 < a ^ 0 b : Ordinal.{u_1} l : IsLimit b a✝ : ∀ (o' : Ordinal.{u_1}), o' < b → 0 < a ^ o' ⊢ 0 < a ^ b ** exact (lt_opow_of_limit (Ordinal.pos_iff_ne_zero.1 a0) l).2 ⟨0, l.pos, h0⟩ ** Qed
| |
Ordinal.opow_isNormal ** a : Ordinal.{u_1} h : 1 < a a0 : 0 < a b : Ordinal.{u_1} ⊢ (fun x x_1 => x ^ x_1) a b < (fun x x_1 => x ^ x_1) a (succ b) ** simpa only [mul_one, opow_succ] using (mul_lt_mul_iff_left (opow_pos b a0)).2 h ** Qed
| |
Ordinal.opow_isLimit_left ** a b : Ordinal.{u_1} l : IsLimit a hb : b ≠ 0 ⊢ IsLimit (a ^ b) ** rcases zero_or_succ_or_limit b with (e | ⟨b, rfl⟩ | l') ** case inl a b : Ordinal.{u_1} l : IsLimit a hb : b ≠ 0 e : b = 0 ⊢ IsLimit (a ^ b) ** exact absurd e hb ** case inr.inl.intro a : Ordinal.{u_1} l : IsLimit a b : Ordinal.{u_1} hb : succ b ≠ 0 ⊢ IsLimit (a ^ succ b) ** rw [opow_succ] ** case inr.inl.intro a : Ordinal.{u_1} l : IsLimit a b : Ordinal.{u_1} hb : succ b ≠ 0 ⊢ IsLimit (a ^ b * a) ** exact mul_isLimit (opow_pos _ l.pos) l ** case inr.inr a b : Ordinal.{u_1} l : IsLimit a hb : b ≠ 0 l' : IsLimit b ⊢ IsLimit (a ^ b) ** exact opow_isLimit l.one_lt l' ** Qed
| |
Ordinal.opow_le_opow_right ** a b c : Ordinal.{u_1} h₁ : 0 < a h₂ : b ≤ c ⊢ a ^ b ≤ a ^ c ** cases' lt_or_eq_of_le (one_le_iff_pos.2 h₁) with h₁ h₁ ** case inl a b c : Ordinal.{u_1} h₁✝ : 0 < a h₂ : b ≤ c h₁ : 1 < a ⊢ a ^ b ≤ a ^ c ** exact (opow_le_opow_iff_right h₁).2 h₂ ** case inr a b c : Ordinal.{u_1} h₁✝ : 0 < a h₂ : b ≤ c h₁ : 1 = a ⊢ a ^ b ≤ a ^ c ** subst a ** case inr b c : Ordinal.{u_1} h₂ : b ≤ c h₁ : 0 < 1 ⊢ 1 ^ b ≤ 1 ^ c ** simp only [one_opow, le_refl] ** Qed
| |
Ordinal.opow_le_opow_left ** a b c : Ordinal.{u_1} ab : a ≤ b ⊢ a ^ c ≤ b ^ c ** by_cases a0 : a = 0 ** case pos a b c : Ordinal.{u_1} ab : a ≤ b a0 : a = 0 ⊢ a ^ c ≤ b ^ c ** subst a ** case pos b c : Ordinal.{u_1} ab : 0 ≤ b ⊢ 0 ^ c ≤ b ^ c ** by_cases c0 : c = 0 ** case pos b c : Ordinal.{u_1} ab : 0 ≤ b c0 : c = 0 ⊢ 0 ^ c ≤ b ^ c ** subst c ** case pos b : Ordinal.{u_1} ab : 0 ≤ b ⊢ 0 ^ 0 ≤ b ^ 0 ** simp only [opow_zero, le_refl] ** case neg b c : Ordinal.{u_1} ab : 0 ≤ b c0 : ¬c = 0 ⊢ 0 ^ c ≤ b ^ c ** simp only [zero_opow c0, Ordinal.zero_le] ** case neg a b c : Ordinal.{u_1} ab : a ≤ b a0 : ¬a = 0 ⊢ a ^ c ≤ b ^ c ** induction c using limitRecOn with
| H₁ => simp only [opow_zero, le_refl]
| H₂ c IH =>
simpa only [opow_succ] using mul_le_mul' IH ab
| H₃ c l IH =>
exact
(opow_le_of_limit a0 l).2 fun b' h =>
(IH _ h).trans (opow_le_opow_right ((Ordinal.pos_iff_ne_zero.2 a0).trans_le ab) h.le) ** case neg.H₁ a b : Ordinal.{u_1} ab : a ≤ b a0 : ¬a = 0 ⊢ a ^ 0 ≤ b ^ 0 ** simp only [opow_zero, le_refl] ** case neg.H₂ a b : Ordinal.{u_1} ab : a ≤ b a0 : ¬a = 0 c : Ordinal.{u_1} IH : a ^ c ≤ b ^ c ⊢ a ^ succ c ≤ b ^ succ c ** simpa only [opow_succ] using mul_le_mul' IH ab ** case neg.H₃ a b : Ordinal.{u_1} ab : a ≤ b a0 : ¬a = 0 c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ o' ≤ b ^ o' ⊢ a ^ c ≤ b ^ c ** exact
(opow_le_of_limit a0 l).2 fun b' h =>
(IH _ h).trans (opow_le_opow_right ((Ordinal.pos_iff_ne_zero.2 a0).trans_le ab) h.le) ** Qed
| |
Ordinal.left_le_opow ** a b : Ordinal.{u_1} b1 : 0 < b ⊢ a ≤ a ^ b ** nth_rw 1 [← opow_one a] ** a b : Ordinal.{u_1} b1 : 0 < b ⊢ a ^ 1 ≤ a ^ b ** cases' le_or_gt a 1 with a1 a1 ** case inr a b : Ordinal.{u_1} b1 : 0 < b a1 : a > 1 ⊢ a ^ 1 ≤ a ^ b ** rwa [opow_le_opow_iff_right a1, one_le_iff_pos] ** case inl a b : Ordinal.{u_1} b1 : 0 < b a1 : a ≤ 1 ⊢ a ^ 1 ≤ a ^ b ** cases' lt_or_eq_of_le a1 with a0 a1 ** case inl.inr a b : Ordinal.{u_1} b1 : 0 < b a1✝ : a ≤ 1 a1 : a = 1 ⊢ a ^ 1 ≤ a ^ b ** rw [a1, one_opow, one_opow] ** case inl.inl a b : Ordinal.{u_1} b1 : 0 < b a1 : a ≤ 1 a0 : a < 1 ⊢ a ^ 1 ≤ a ^ b ** rw [lt_one_iff_zero] at a0 ** case inl.inl a b : Ordinal.{u_1} b1 : 0 < b a1 : a ≤ 1 a0 : a = 0 ⊢ a ^ 1 ≤ a ^ b ** rw [a0, zero_opow Ordinal.one_ne_zero] ** case inl.inl a b : Ordinal.{u_1} b1 : 0 < b a1 : a ≤ 1 a0 : a = 0 ⊢ 0 ≤ 0 ^ b ** exact Ordinal.zero_le _ ** Qed
| |
Ordinal.opow_lt_opow_left_of_succ ** a b c : Ordinal.{u_1} ab : a < b ⊢ a ^ succ c < b ^ succ c ** rw [opow_succ, opow_succ] ** a b c : Ordinal.{u_1} ab : a < b ⊢ a ^ c * a < b ^ c * b ** exact
(mul_le_mul_right' (opow_le_opow_left c ab.le) a).trans_lt
(mul_lt_mul_of_pos_left ab (opow_pos c ((Ordinal.zero_le a).trans_lt ab))) ** Qed
| |
Ordinal.opow_add ** a b c : Ordinal.{u_1} ⊢ a ^ (b + c) = a ^ b * a ^ c ** rcases eq_or_ne a 0 with (rfl | a0) ** case inr a b c : Ordinal.{u_1} a0 : a ≠ 0 ⊢ a ^ (b + c) = a ^ b * a ^ c ** rcases eq_or_lt_of_le (one_le_iff_ne_zero.2 a0) with (rfl | a1) ** case inr.inr a b c : Ordinal.{u_1} a0 : a ≠ 0 a1 : 1 < a ⊢ a ^ (b + c) = a ^ b * a ^ c ** induction c using limitRecOn with
| H₁ => simp
| H₂ c IH =>
rw [add_succ, opow_succ, IH, opow_succ, mul_assoc]
| H₃ c l IH =>
refine'
eq_of_forall_ge_iff fun d =>
(((opow_isNormal a1).trans (add_isNormal b)).limit_le l).trans _
dsimp only [Function.comp]
simp (config := { contextual := true }) only [IH]
exact
(((mul_isNormal <| opow_pos b (Ordinal.pos_iff_ne_zero.2 a0)).trans
(opow_isNormal a1)).limit_le
l).symm ** case inl b c : Ordinal.{u_1} ⊢ 0 ^ (b + c) = 0 ^ b * 0 ^ c ** rcases eq_or_ne c 0 with (rfl | c0) ** case inl.inr b c : Ordinal.{u_1} c0 : c ≠ 0 ⊢ 0 ^ (b + c) = 0 ^ b * 0 ^ c ** have : b + c ≠ 0 := ((Ordinal.pos_iff_ne_zero.2 c0).trans_le (le_add_left _ _)).ne' ** case inl.inr b c : Ordinal.{u_1} c0 : c ≠ 0 this : b + c ≠ 0 ⊢ 0 ^ (b + c) = 0 ^ b * 0 ^ c ** simp only [zero_opow c0, zero_opow this, mul_zero] ** case inl.inl b : Ordinal.{u_1} ⊢ 0 ^ (b + 0) = 0 ^ b * 0 ^ 0 ** simp ** case inr.inl b c : Ordinal.{u_1} a0 : 1 ≠ 0 ⊢ 1 ^ (b + c) = 1 ^ b * 1 ^ c ** simp only [one_opow, mul_one] ** case inr.inr.H₁ a b : Ordinal.{u_1} a0 : a ≠ 0 a1 : 1 < a ⊢ a ^ (b + 0) = a ^ b * a ^ 0 ** simp ** case inr.inr.H₂ a b : Ordinal.{u_1} a0 : a ≠ 0 a1 : 1 < a c : Ordinal.{u_1} IH : a ^ (b + c) = a ^ b * a ^ c ⊢ a ^ (b + succ c) = a ^ b * a ^ succ c ** rw [add_succ, opow_succ, IH, opow_succ, mul_assoc] ** case inr.inr.H₃ a b : Ordinal.{u_1} a0 : a ≠ 0 a1 : 1 < a c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ (b + o') = a ^ b * a ^ o' ⊢ a ^ (b + c) = a ^ b * a ^ c ** refine'
eq_of_forall_ge_iff fun d =>
(((opow_isNormal a1).trans (add_isNormal b)).limit_le l).trans _ ** case inr.inr.H₃ a b : Ordinal.{u_1} a0 : a ≠ 0 a1 : 1 < a c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ (b + o') = a ^ b * a ^ o' d : Ordinal.{u_1} ⊢ (∀ (b_1 : Ordinal.{u_1}), b_1 < c → ((fun x x_1 => x ^ x_1) a ∘ (fun x x_1 => x + x_1) b) b_1 ≤ d) ↔ a ^ b * a ^ c ≤ d ** dsimp only [Function.comp] ** case inr.inr.H₃ a b : Ordinal.{u_1} a0 : a ≠ 0 a1 : 1 < a c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ (b + o') = a ^ b * a ^ o' d : Ordinal.{u_1} ⊢ (∀ (b_1 : Ordinal.{u_1}), b_1 < c → a ^ (b + b_1) ≤ d) ↔ a ^ b * a ^ c ≤ d ** simp (config := { contextual := true }) only [IH] ** case inr.inr.H₃ a b : Ordinal.{u_1} a0 : a ≠ 0 a1 : 1 < a c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ (b + o') = a ^ b * a ^ o' d : Ordinal.{u_1} ⊢ (∀ (b_1 : Ordinal.{u_1}), b_1 < c → a ^ b * a ^ b_1 ≤ d) ↔ a ^ b * a ^ c ≤ d ** exact
(((mul_isNormal <| opow_pos b (Ordinal.pos_iff_ne_zero.2 a0)).trans
(opow_isNormal a1)).limit_le
l).symm ** Qed
| |
Ordinal.opow_one_add ** a b : Ordinal.{u_1} ⊢ a ^ (1 + b) = a * a ^ b ** rw [opow_add, opow_one] ** Qed
| |
Ordinal.opow_dvd_opow ** a b c : Ordinal.{u_1} h : b ≤ c ⊢ a ^ c = a ^ b * a ^ (c - b) ** rw [← opow_add, Ordinal.add_sub_cancel_of_le h] ** Qed
| |
Ordinal.opow_mul ** a b c : Ordinal.{u_1} ⊢ a ^ (b * c) = (a ^ b) ^ c ** by_cases b0 : b = 0 ** case neg a b c : Ordinal.{u_1} b0 : ¬b = 0 ⊢ a ^ (b * c) = (a ^ b) ^ c ** by_cases a0 : a = 0 ** case neg a b c : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 ⊢ a ^ (b * c) = (a ^ b) ^ c ** cases' eq_or_lt_of_le (one_le_iff_ne_zero.2 a0) with a1 a1 ** case neg.inr a b c : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 a1 : 1 < a ⊢ a ^ (b * c) = (a ^ b) ^ c ** induction c using limitRecOn with
| H₁ => simp only [mul_zero, opow_zero]
| H₂ c IH =>
rw [mul_succ, opow_add, IH, opow_succ]
| H₃ c l IH =>
refine'
eq_of_forall_ge_iff fun d =>
(((opow_isNormal a1).trans (mul_isNormal (Ordinal.pos_iff_ne_zero.2 b0))).limit_le
l).trans
_
dsimp only [Function.comp]
simp (config := { contextual := true }) only [IH]
exact (opow_le_of_limit (opow_ne_zero _ a0) l).symm ** case pos a b c : Ordinal.{u_1} b0 : b = 0 ⊢ a ^ (b * c) = (a ^ b) ^ c ** simp only [b0, zero_mul, opow_zero, one_opow] ** case pos a b c : Ordinal.{u_1} b0 : ¬b = 0 a0 : a = 0 ⊢ a ^ (b * c) = (a ^ b) ^ c ** subst a ** case pos b c : Ordinal.{u_1} b0 : ¬b = 0 ⊢ 0 ^ (b * c) = (0 ^ b) ^ c ** by_cases c0 : c = 0 ** case neg b c : Ordinal.{u_1} b0 : ¬b = 0 c0 : ¬c = 0 ⊢ 0 ^ (b * c) = (0 ^ b) ^ c ** simp only [zero_opow b0, zero_opow c0, zero_opow (mul_ne_zero b0 c0)] ** case pos b c : Ordinal.{u_1} b0 : ¬b = 0 c0 : c = 0 ⊢ 0 ^ (b * c) = (0 ^ b) ^ c ** simp only [c0, mul_zero, opow_zero] ** case neg.inl a b c : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 a1 : 1 = a ⊢ a ^ (b * c) = (a ^ b) ^ c ** subst a1 ** case neg.inl b c : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬1 = 0 ⊢ 1 ^ (b * c) = (1 ^ b) ^ c ** simp only [one_opow] ** case neg.inr.H₁ a b : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 a1 : 1 < a ⊢ a ^ (b * 0) = (a ^ b) ^ 0 ** simp only [mul_zero, opow_zero] ** case neg.inr.H₂ a b : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 a1 : 1 < a c : Ordinal.{u_1} IH : a ^ (b * c) = (a ^ b) ^ c ⊢ a ^ (b * succ c) = (a ^ b) ^ succ c ** rw [mul_succ, opow_add, IH, opow_succ] ** case neg.inr.H₃ a b : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 a1 : 1 < a c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ (b * o') = (a ^ b) ^ o' ⊢ a ^ (b * c) = (a ^ b) ^ c ** refine'
eq_of_forall_ge_iff fun d =>
(((opow_isNormal a1).trans (mul_isNormal (Ordinal.pos_iff_ne_zero.2 b0))).limit_le
l).trans
_ ** case neg.inr.H₃ a b : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 a1 : 1 < a c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ (b * o') = (a ^ b) ^ o' d : Ordinal.{u_1} ⊢ (∀ (b_1 : Ordinal.{u_1}), b_1 < c → ((fun x x_1 => x ^ x_1) a ∘ (fun x x_1 => x * x_1) b) b_1 ≤ d) ↔ (a ^ b) ^ c ≤ d ** dsimp only [Function.comp] ** case neg.inr.H₃ a b : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 a1 : 1 < a c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ (b * o') = (a ^ b) ^ o' d : Ordinal.{u_1} ⊢ (∀ (b_1 : Ordinal.{u_1}), b_1 < c → a ^ (b * b_1) ≤ d) ↔ (a ^ b) ^ c ≤ d ** simp (config := { contextual := true }) only [IH] ** case neg.inr.H₃ a b : Ordinal.{u_1} b0 : ¬b = 0 a0 : ¬a = 0 a1 : 1 < a c : Ordinal.{u_1} l : IsLimit c IH : ∀ (o' : Ordinal.{u_1}), o' < c → a ^ (b * o') = (a ^ b) ^ o' d : Ordinal.{u_1} ⊢ (∀ (b_1 : Ordinal.{u_1}), b_1 < c → (a ^ b) ^ b_1 ≤ d) ↔ (a ^ b) ^ c ≤ d ** exact (opow_le_of_limit (opow_ne_zero _ a0) l).symm ** Qed
| |
Ordinal.log_def ** b : Ordinal.{u_1} h : 1 < b x : Ordinal.{u_1} ⊢ log b x = pred (sInf {o | x < b ^ o}) ** simp only [log, dif_pos h] ** Qed
| |
Ordinal.log_of_not_one_lt_left ** b : Ordinal.{u_1} h : ¬1 < b x : Ordinal.{u_1} ⊢ log b x = 0 ** simp only [log, dif_neg h] ** Qed
| |
Ordinal.log_zero_right ** b : Ordinal.{u_1} b1 : 1 < b ⊢ log b 0 = 0 ** rw [log_def b1, ← Ordinal.le_zero, pred_le] ** b : Ordinal.{u_1} b1 : 1 < b ⊢ sInf {o | 0 < b ^ o} ≤ succ 0 ** apply csInf_le' ** case h b : Ordinal.{u_1} b1 : 1 < b ⊢ succ 0 ∈ {o | 0 < b ^ o} ** dsimp ** case h b : Ordinal.{u_1} b1 : 1 < b ⊢ 0 < b ^ succ 0 ** rw [succ_zero, opow_one] ** case h b : Ordinal.{u_1} b1 : 1 < b ⊢ 0 < b ** exact zero_lt_one.trans b1 ** b : Ordinal.{u_1} b1 : ¬1 < b ⊢ log b 0 = 0 ** simp only [log_of_not_one_lt_left b1] ** Qed
| |
Ordinal.succ_log_def ** b x : Ordinal.{u_1} hb : 1 < b hx : x ≠ 0 ⊢ succ (log b x) = sInf {o | x < b ^ o} ** let t := sInf { o | x < (b^o) } ** b x : Ordinal.{u_1} hb : 1 < b hx : x ≠ 0 t : Ordinal.{u_1} := sInf {o | x < b ^ o} ⊢ succ (log b x) = sInf {o | x < b ^ o} ** have : x < (b^t) := csInf_mem (log_nonempty hb) ** b x : Ordinal.{u_1} hb : 1 < b hx : x ≠ 0 t : Ordinal.{u_1} := sInf {o | x < b ^ o} this : x < b ^ t ⊢ succ (log b x) = sInf {o | x < b ^ o} ** rcases zero_or_succ_or_limit t with (h | h | h) ** case inl b x : Ordinal.{u_1} hb : 1 < b hx : x ≠ 0 t : Ordinal.{u_1} := sInf {o | x < b ^ o} this : x < b ^ t h : t = 0 ⊢ succ (log b x) = sInf {o | x < b ^ o} ** refine' ((one_le_iff_ne_zero.2 hx).not_lt _).elim ** case inl b x : Ordinal.{u_1} hb : 1 < b hx : x ≠ 0 t : Ordinal.{u_1} := sInf {o | x < b ^ o} this : x < b ^ t h : t = 0 ⊢ x < 1 ** simpa only [h, opow_zero] using this ** case inr.inl b x : Ordinal.{u_1} hb : 1 < b hx : x ≠ 0 t : Ordinal.{u_1} := sInf {o | x < b ^ o} this : x < b ^ t h : ∃ a, t = succ a ⊢ succ (log b x) = sInf {o | x < b ^ o} ** rw [show log b x = pred t from log_def hb x, succ_pred_iff_is_succ.2 h] ** case inr.inr b x : Ordinal.{u_1} hb : 1 < b hx : x ≠ 0 t : Ordinal.{u_1} := sInf {o | x < b ^ o} this : x < b ^ t h : IsLimit t ⊢ succ (log b x) = sInf {o | x < b ^ o} ** rcases (lt_opow_of_limit (zero_lt_one.trans hb).ne' h).1 this with ⟨a, h₁, h₂⟩ ** case inr.inr.intro.intro b x : Ordinal.{u_1} hb : 1 < b hx : x ≠ 0 t : Ordinal.{u_1} := sInf {o | x < b ^ o} this : x < b ^ t h : IsLimit t a : Ordinal.{u_1} h₁ : a < t h₂ : x < b ^ a ⊢ succ (log b x) = sInf {o | x < b ^ o} ** exact h₁.not_le.elim ((le_csInf_iff'' (log_nonempty hb)).1 le_rfl a h₂) ** Qed
| |
Ordinal.lt_opow_succ_log_self ** b : Ordinal.{u_1} hb : 1 < b x : Ordinal.{u_1} ⊢ x < b ^ succ (log b x) ** rcases eq_or_ne x 0 with (rfl | hx) ** case inl b : Ordinal.{u_1} hb : 1 < b ⊢ 0 < b ^ succ (log b 0) ** apply opow_pos _ (zero_lt_one.trans hb) ** case inr b : Ordinal.{u_1} hb : 1 < b x : Ordinal.{u_1} hx : x ≠ 0 ⊢ x < b ^ succ (log b x) ** rw [succ_log_def hb hx] ** case inr b : Ordinal.{u_1} hb : 1 < b x : Ordinal.{u_1} hx : x ≠ 0 ⊢ x < b ^ sInf {o | x < b ^ o} ** exact csInf_mem (log_nonempty hb) ** Qed
| |
Ordinal.opow_log_le_self ** b x : Ordinal.{u_1} hx : x ≠ 0 ⊢ b ^ log b x ≤ x ** rcases eq_or_ne b 0 with (rfl | b0) ** case inr b x : Ordinal.{u_1} hx : x ≠ 0 b0 : b ≠ 0 ⊢ b ^ log b x ≤ x ** rcases lt_or_eq_of_le (one_le_iff_ne_zero.2 b0) with (hb | rfl) ** case inl x : Ordinal.{u_1} hx : x ≠ 0 ⊢ 0 ^ log 0 x ≤ x ** rw [zero_opow'] ** case inl x : Ordinal.{u_1} hx : x ≠ 0 ⊢ 1 - log 0 x ≤ x ** refine' (sub_le_self _ _).trans (one_le_iff_ne_zero.2 hx) ** case inr.inl b x : Ordinal.{u_1} hx : x ≠ 0 b0 : b ≠ 0 hb : 1 < b ⊢ b ^ log b x ≤ x ** refine' le_of_not_lt fun h => (lt_succ (log b x)).not_le _ ** case inr.inl b x : Ordinal.{u_1} hx : x ≠ 0 b0 : b ≠ 0 hb : 1 < b h : x < b ^ log b x ⊢ succ (log b x) ≤ log b x ** have := @csInf_le' _ _ { o | x < (b^o) } _ h ** case inr.inl b x : Ordinal.{u_1} hx : x ≠ 0 b0 : b ≠ 0 hb : 1 < b h : x < b ^ log b x this : sInf {o | x < b ^ o} ≤ log b x ⊢ succ (log b x) ≤ log b x ** rwa [← succ_log_def hb hx] at this ** case inr.inr x : Ordinal.{u_1} hx : x ≠ 0 b0 : 1 ≠ 0 ⊢ 1 ^ log 1 x ≤ x ** rwa [one_opow, one_le_iff_ne_zero] ** Qed
| |
Ordinal.log_pos ** b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o ⊢ 0 < log b o ** rwa [← succ_le_iff, succ_zero, ← opow_le_iff_le_log hb ho, opow_one] ** Qed
| |
Ordinal.log_eq_zero ** b o : Ordinal.{u_1} hbo : o < b ⊢ log b o = 0 ** rcases eq_or_ne o 0 with (rfl | ho) ** case inr b o : Ordinal.{u_1} hbo : o < b ho : o ≠ 0 ⊢ log b o = 0 ** cases' le_or_lt b 1 with hb hb ** case inl b : Ordinal.{u_1} hbo : 0 < b ⊢ log b 0 = 0 ** exact log_zero_right b ** case inr.inl b o : Ordinal.{u_1} hbo : o < b ho : o ≠ 0 hb : b ≤ 1 ⊢ log b o = 0 ** rcases le_one_iff.1 hb with (rfl | rfl) ** case inr.inl.inl o : Ordinal.{u_1} ho : o ≠ 0 hbo : o < 0 hb : 0 ≤ 1 ⊢ log 0 o = 0 ** exact log_zero_left o ** case inr.inl.inr o : Ordinal.{u_1} ho : o ≠ 0 hbo : o < 1 hb : 1 ≤ 1 ⊢ log 1 o = 0 ** exact log_one_left o ** case inr.inr b o : Ordinal.{u_1} hbo : o < b ho : o ≠ 0 hb : 1 < b ⊢ log b o = 0 ** rwa [← Ordinal.le_zero, ← lt_succ_iff, succ_zero, ← lt_opow_iff_log_lt hb ho, opow_one] ** Qed
| |
Ordinal.log_mono_right ** b x y : Ordinal.{u_1} xy : x ≤ y hx : x = 0 ⊢ log b x ≤ log b y ** simp only [hx, log_zero_right, Ordinal.zero_le] ** b x y : Ordinal.{u_1} xy : x ≤ y hx : ¬x = 0 hb : ¬1 < b ⊢ log b x ≤ log b y ** simp only [log_of_not_one_lt_left hb, Ordinal.zero_le] ** Qed
| |
Ordinal.log_le_self ** b x : Ordinal.{u_1} hx : x = 0 ⊢ log b x ≤ x ** simp only [hx, log_zero_right, Ordinal.zero_le] ** b x : Ordinal.{u_1} hx : ¬x = 0 hb : ¬1 < b ⊢ log b x ≤ x ** simp only [log_of_not_one_lt_left hb, Ordinal.zero_le] ** Qed
| |
Ordinal.mod_opow_log_lt_self ** b o : Ordinal.{u_1} ho : o ≠ 0 ⊢ o % b ^ log b o < o ** rcases eq_or_ne b 0 with (rfl | hb) ** case inl o : Ordinal.{u_1} ho : o ≠ 0 ⊢ o % 0 ^ log 0 o < o ** simpa using Ordinal.pos_iff_ne_zero.2 ho ** case inr b o : Ordinal.{u_1} ho : o ≠ 0 hb : b ≠ 0 ⊢ o % b ^ log b o < o ** exact (mod_lt _ <| opow_ne_zero _ hb).trans_le (opow_log_le_self _ ho) ** Qed
| |
Ordinal.log_mod_opow_log_lt_log_self ** b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o ⊢ log b (o % b ^ log b o) < log b o ** cases' eq_or_ne (o % (b^log b o)) 0 with h h ** case inl b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o h : o % b ^ log b o = 0 ⊢ log b (o % b ^ log b o) < log b o ** rw [h, log_zero_right] ** case inl b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o h : o % b ^ log b o = 0 ⊢ 0 < log b o ** apply log_pos hb ho hbo ** case inr b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o h : o % b ^ log b o ≠ 0 ⊢ log b (o % b ^ log b o) < log b o ** rw [← succ_le_iff, succ_log_def hb h] ** case inr b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o h : o % b ^ log b o ≠ 0 ⊢ sInf {o_1 | o % b ^ log b o < b ^ o_1} ≤ log b o ** apply csInf_le' ** case inr.h b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o h : o % b ^ log b o ≠ 0 ⊢ log b o ∈ {o_1 | o % b ^ log b o < b ^ o_1} ** apply mod_lt ** case inr.h.h b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o h : o % b ^ log b o ≠ 0 ⊢ b ^ log b o ≠ 0 ** rw [← Ordinal.pos_iff_ne_zero] ** case inr.h.h b o : Ordinal.{u_1} hb : 1 < b ho : o ≠ 0 hbo : b ≤ o h : o % b ^ log b o ≠ 0 ⊢ 0 < b ^ log b o ** exact opow_pos _ (zero_lt_one.trans hb) ** Qed
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.