l3lab/ntp-mathlib huggingface dataset:
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (

Proof state:
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)

Next tactic:
try rw [add_moveLeft_inl]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (try 

Proof state:
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)

Next tactic:
rw [add_moveLeft_inl]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (

Proof state:
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)

Next tactic:
try rw [add_moveLeft_inl]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (try 

Proof state:
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)

Next tactic:
rw [add_moveLeft_inl]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (try rw [add_moveLeft_inl]) <;>
      (

Proof state:
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) i + toPGame b ⧏ toPGame (a ♯ b)

Next tactic:
try rw [add_moveLeft_inr]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (try rw [add_moveLeft_inl]) <;>
      (try 

Proof state:
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) i + toPGame b ⧏ toPGame (a ♯ b)

Next tactic:
rw [add_moveLeft_inr]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (try rw [add_moveLeft_inl]) <;>
      (

Proof state:
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)

Next tactic:
try rw [add_moveLeft_inr]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (try rw [add_moveLeft_inl]) <;>
      (try 

Proof state:
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)

Next tactic:
rw [add_moveLeft_inr]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (try rw [add_moveLeft_inl]) <;>
      (try rw [add_moveLeft_inr]) <;>
      

Proof state:
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) i + toPGame b ⧏ toPGame (a ♯ b)

Next tactic:
rw [toPGame_moveLeft', lf_congr_left (toPGame_add _ _), toPGame_lf_iff]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · apply leftMoves_add_cases i <;>
      intro i <;>
      let wf := toLeftMovesToPGame_symm_lt i <;>
      (try rw [add_moveLeft_inl]) <;>
      (try rw [add_moveLeft_inr]) <;>
      

Proof state:
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
⊢ toPGame a + moveLeft (toPGame b) i ⧏ toPGame (a ♯ b)

Next tactic:
rw [toPGame_moveLeft', lf_congr_left (toPGame_add _ _), toPGame_lf_iff]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · 

Proof state:
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

Next tactic:
exact nadd_lt_nadd_right wf _
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · 

Proof state:
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

Next tactic:
exact nadd_lt_nadd_left wf _
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · 

Proof state:
case refine'_2
a b : Ordinal.{u}
i : LeftMoves (toPGame (a ♯ b))
⊢ moveLeft (toPGame (a ♯ b)) i ⧏ toPGame a + toPGame b

Next tactic:
rw [toPGame_moveLeft']
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      

Proof state:
case refine'_2
a b : Ordinal.{u}
i : LeftMoves (toPGame (a ♯ b))
⊢ toPGame ↑(toLeftMovesToPGame.symm i) ⧏ toPGame a + toPGame b

Next tactic:
rcases lt_nadd_iff.1 (toLeftMovesToPGame_symm_lt i) with (⟨c, hc, hc'⟩ | ⟨c, hc, hc'⟩)
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      rcases lt_nadd_iff.1 (toLeftMovesToPGame_symm_lt i) with (⟨c, hc, hc'⟩ | ⟨c, hc, hc'⟩) <;>
      

Proof state:
case refine'_2.inl.intro.intro
a b : Ordinal.{u}
i : LeftMoves (toPGame (a ♯ b))
c : Ordinal.{u}
hc : c < a
hc' : ↑(toLeftMovesToPGame.symm i) ≤ c ♯ b
⊢ toPGame ↑(toLeftMovesToPGame.symm i) ⧏ toPGame a + toPGame b

Next tactic:
rw [← toPGame_le_iff, ← le_congr_right (toPGame_add _ _)] at hc'
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      rcases lt_nadd_iff.1 (toLeftMovesToPGame_symm_lt i) with (⟨c, hc, hc'⟩ | ⟨c, hc, hc'⟩) <;>
      

Proof state:
case refine'_2.inr.intro.intro
a b : Ordinal.{u}
i : LeftMoves (toPGame (a ♯ b))
c : Ordinal.{u}
hc : c < b
hc' : ↑(toLeftMovesToPGame.symm i) ≤ a ♯ c
⊢ toPGame ↑(toLeftMovesToPGame.symm i) ⧏ toPGame a + toPGame b

Next tactic:
rw [← toPGame_le_iff, ← le_congr_right (toPGame_add _ _)] at hc'
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      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' <;>
      

Proof state:
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 ↑(toLeftMovesToPGame.symm i) ⧏ toPGame a + toPGame b

Next tactic:
apply lf_of_le_of_lf hc'
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      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' <;>
      

Proof state:
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 ↑(toLeftMovesToPGame.symm i) ⧏ toPGame a + toPGame b

Next tactic:
apply lf_of_le_of_lf hc'
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      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'
      · 

Proof state:
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

Next tactic:
apply add_lf_add_right
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      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'
      · apply add_lf_add_right
        

Proof state:
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

Next tactic:
rwa [toPGame_lf_iff]
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      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'
      · apply add_lf_add_right
        rwa [toPGame_lf_iff]
      · 

Proof state:
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

Next tactic:
apply add_lf_add_left
/-- The sum of ordinals as games corresponds to natural addition of ordinals. -/
theorem toPGame_add : ∀ a b : Ordinal.{u}, a.toPGame + b.toPGame ≈ (a ♯ b).toPGame
  | a, b => by
    refine' ⟨le_of_forall_lf (fun i => _) isEmptyElim, le_of_forall_lf (fun i => _) isEmptyElim⟩
    · 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]
      · exact nadd_lt_nadd_right wf _
      · exact nadd_lt_nadd_left wf _
    · rw [toPGame_moveLeft']
      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'
      · apply add_lf_add_right
        rwa [toPGame_lf_iff]
      · apply add_lf_add_left
        

Proof state:
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

Next tactic:
rwa [toPGame_lf_iff]
theorem Valuation.inversion_estimate {x y : K} {γ : Γ₀ˣ} (y_ne : y ≠ 0)
    (h : v (x - y) < min (γ * (v y * v y)) (v y)) : v (x⁻¹ - y⁻¹) < γ := by
  

Proof state:
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : v (x - y) < min (↑γ * (v y * v y)) (v y)
⊢ v (x⁻¹ - y⁻¹) < ↑γ

Next tactic:
have hyp1 : v (x - y) < γ * (v y * v y) := lt_of_lt_of_le h (min_le_left _ _)
theorem Valuation.inversion_estimate {x y : K} {γ : Γ₀ˣ} (y_ne : y ≠ 0)
    (h : v (x - y) < min (γ * (v y * v y)) (v y)) : v (x⁻¹ - y⁻¹) < γ := by
  have hyp1 : v (x - y) < γ * (v y * v y) := lt_of_lt_of_le h (min_le_left _ _)
  

Proof state:
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : v (x - y) < min (↑γ * (v y * v y)) (v y)
hyp1 : v (x - y) < ↑γ * (v y * v y)
⊢ v (x⁻¹ - y⁻¹) < ↑γ

Next tactic:
have hyp1' : v (x - y) * (v y * v y)⁻¹ < γ := mul_inv_lt_of_lt_mul₀ hyp1
theorem Valuation.inversion_estimate {x y : K} {γ : Γ₀ˣ} (y_ne : y ≠ 0)
    (h : v (x - y) < min (γ * (v y * v y)) (v y)) : v (x⁻¹ - y⁻¹) < γ := by
  have hyp1 : v (x - y) < γ * (v y * v y) := lt_of_lt_of_le h (min_le_left _ _)
  have hyp1' : v (x - y) * (v y * v y)⁻¹ < γ := mul_inv_lt_of_lt_mul₀ hyp1
  

Proof state:
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : v (x - y) < min (↑γ * (v y * v y)) (v y)
hyp1 : v (x - y) < ↑γ * (v y * v y)
hyp1' : v (x - y) * (v y * v y)⁻¹ < ↑γ
⊢ v (x⁻¹ - y⁻¹) < ↑γ

Next tactic:
have hyp2 : v (x - y) < v y := lt_of_lt_of_le h (min_le_right _ _)
theorem Valuation.inversion_estimate {x y : K} {γ : Γ₀ˣ} (y_ne : y ≠ 0)
    (h : v (x - y) < min (γ * (v y * v y)) (v y)) : v (x⁻¹ - y⁻¹) < γ := by
  have hyp1 : v (x - y) < γ * (v y * v y) := lt_of_lt_of_le h (min_le_left _ _)
  have hyp1' : v (x - y) * (v y * v y)⁻¹ < γ := mul_inv_lt_of_lt_mul₀ hyp1
  have hyp2 : v (x - y) < v y := lt_of_lt_of_le h (min_le_right _ _)
  

Proof state:
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : v (x - y) < min (↑γ * (v y * v y)) (v y)
hyp1 : v (x - y) < ↑γ * (v y * v y)
hyp1' : v (x - y) * (v y * v y)⁻¹ < ↑γ
hyp2 : v (x - y) < v y
⊢ v (x⁻¹ - y⁻¹) < ↑γ

Next tactic:
have key : v x = v y := Valuation.map_eq_of_sub_lt v hyp2
theorem Valuation.inversion_estimate {x y : K} {γ : Γ₀ˣ} (y_ne : y ≠ 0)
    (h : v (x - y) < min (γ * (v y * v y)) (v y)) : v (x⁻¹ - y⁻¹) < γ := by
  have hyp1 : v (x - y) < γ * (v y * v y) := lt_of_lt_of_le h (min_le_left _ _)
  have hyp1' : v (x - y) * (v y * v y)⁻¹ < γ := mul_inv_lt_of_lt_mul₀ hyp1
  have hyp2 : v (x - y) < v y := lt_of_lt_of_le h (min_le_right _ _)
  have key : v x = v y := Valuation.map_eq_of_sub_lt v hyp2
  

Proof state:
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : v (x - y) < min (↑γ * (v y * v y)) (v y)
hyp1 : v (x - y) < ↑γ * (v y * v y)
hyp1' : v (x - y) * (v y * v y)⁻¹ < ↑γ
hyp2 : v (x - y) < v y
key : v x = v y
⊢ v (x⁻¹ - y⁻¹) < ↑γ

Next tactic:
have x_ne : x ≠ 0 := by
    intro h
    apply y_ne
    rw [h, v.map_zero] at key
    exact v.zero_iff.1 key.symm
theorem Valuation.inversion_estimate {x y : K} {γ : Γ₀ˣ} (y_ne : y ≠ 0)
    (h : v (x - y) < min (γ * (v y * v y)) (v y)) : v (x⁻¹ - y⁻¹) < γ := by
  have hyp1 : v (x - y) < γ * (v y * v y) := lt_of_lt_of_le h (min_le_left _ _)
  have hyp1' : v (x - y) * (v y * v y)⁻¹ < γ := mul_inv_lt_of_lt_mul₀ hyp1
  have hyp2 : v (x - y) < v y := lt_of_lt_of_le h (min_le_right _ _)
  have key : v x = v y := Valuation.map_eq_of_sub_lt v hyp2
  have x_ne : x ≠ 0 := by
    

Proof state:
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : v (x - y) < min (↑γ * (v y * v y)) (v y)
hyp1 : v (x - y) < ↑γ * (v y * v y)
hyp1' : v (x - y) * (v y * v y)⁻¹ < ↑γ
hyp2 : v (x - y) < v y
key : v x = v y
⊢ x ≠ 0

Next tactic:
intro h