l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  

Proof state:
case funMap.h.h.h
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
x✝² : ℕ
x✝¹ : Functions Language.graph x✝²
x✝ : Fin x✝² → V
⊢ funMap x✝¹ x✝ = funMap x✝¹ x✝
case RelMap.h.h.h.a
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
x✝² : ℕ
x✝¹ : Relations Language.graph x✝²
x✝ : Fin x✝² → V
⊢ RelMap x✝¹ x✝ ↔ RelMap x✝¹ x✝

Next tactic:
case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  

Proof state:
L : Language
α : Type w
V : Type w'
n✝ : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
n : ℕ
f : Functions Language.graph n
xs : Fin n → V
⊢ funMap f xs = funMap f xs

Next tactic:
case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    

Proof state:
L : Language
α : Type w
V : Type w'
n✝ : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
n : ℕ
f : Functions Language.graph n
xs : Fin n → V
⊢ funMap f xs = funMap f xs

Next tactic:
exact (IsRelational.empty_functions n).elim f
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  

Proof state:
case RelMap.h.h.h.a
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
x✝² : ℕ
x✝¹ : Relations Language.graph x✝²
x✝ : Fin x✝² → V
⊢ RelMap x✝¹ x✝ ↔ RelMap x✝¹ x✝

Next tactic:
case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · exact r.elim
      · cases' n with n
        · cases r
          change RelMap adj ![xs 0, xs 1] = _
          refine' congr rfl (funext _)
          simp [Fin.forall_fin_two]
        · exact r.elim
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  

Proof state:
L : Language
α : Type w
V : Type w'
n✝ : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
n : ℕ
r : Relations Language.graph n
xs : Fin n → V
⊢ RelMap r xs ↔ RelMap r xs

Next tactic:
case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · exact r.elim
      · cases' n with n
        · cases r
          change RelMap adj ![xs 0, xs 1] = _
          refine' congr rfl (funext _)
          simp [Fin.forall_fin_two]
        · exact r.elim
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    

Proof state:
L : Language
α : Type w
V : Type w'
n✝ : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
n : ℕ
r : Relations Language.graph n
xs : Fin n → V
⊢ RelMap r xs ↔ RelMap r xs

Next tactic:
rw [iff_eq_eq]
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    

Proof state:
L : Language
α : Type w
V : Type w'
n✝ : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
n : ℕ
r : Relations Language.graph n
xs : Fin n → V
⊢ RelMap r xs = RelMap r xs

Next tactic:
cases' n with n
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · 

Proof state:
case zero
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
r : Relations Language.graph Nat.zero
xs : Fin Nat.zero → V
⊢ RelMap r xs = RelMap r xs

Next tactic:
exact r.elim
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · 

Proof state:
case succ
L : Language
α : Type w
V : Type w'
n✝ : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
n : ℕ
r : Relations Language.graph (Nat.succ n)
xs : Fin (Nat.succ n) → V
⊢ RelMap r xs = RelMap r xs

Next tactic:
cases' n with n
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · 

Proof state:
case succ.zero
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
r : Relations Language.graph (Nat.succ Nat.zero)
xs : Fin (Nat.succ Nat.zero) → V
⊢ RelMap r xs = RelMap r xs

Next tactic:
exact r.elim
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · exact r.elim
      · 

Proof state:
case succ.succ
L : Language
α : Type w
V : Type w'
n✝ : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
n : ℕ
r : Relations Language.graph (Nat.succ (Nat.succ n))
xs : Fin (Nat.succ (Nat.succ n)) → V
⊢ RelMap r xs = RelMap r xs

Next tactic:
cases' n with n
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · exact r.elim
      · cases' n with n
        · 

Proof state:
case succ.succ.zero
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
r : Relations Language.graph (Nat.succ (Nat.succ Nat.zero))
xs : Fin (Nat.succ (Nat.succ Nat.zero)) → V
⊢ RelMap r xs = RelMap r xs

Next tactic:
cases r
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · exact r.elim
      · cases' n with n
        · cases r
          

Proof state:
case succ.succ.zero.unit
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
xs : Fin (Nat.succ (Nat.succ Nat.zero)) → V
⊢ RelMap PUnit.unit xs = RelMap PUnit.unit xs

Next tactic:
change RelMap adj ![xs 0, xs 1] = _
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · exact r.elim
      · cases' n with n
        · cases r
          change RelMap adj ![xs 0, xs 1] = _
          

Proof state:
case succ.succ.zero.unit
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
xs : Fin (Nat.succ (Nat.succ Nat.zero)) → V
⊢ RelMap adj ![xs 0, xs 1] = RelMap PUnit.unit xs

Next tactic:
refine' congr rfl (funext _)
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · exact r.elim
      · cases' n with n
        · cases r
          change RelMap adj ![xs 0, xs 1] = _
          refine' congr rfl (funext _)
          

Proof state:
case succ.succ.zero.unit
L : Language
α : Type w
V : Type w'
n : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
xs : Fin (Nat.succ (Nat.succ Nat.zero)) → V
⊢ ∀ (x : Fin (Nat.succ 1)), Matrix.vecCons (xs 0) ![xs 1] x = xs x

Next tactic:
simp [Fin.forall_fin_two]
@[simp]
theorem structure_simpleGraphOfStructure [S : Language.graph.Structure V] [V ⊨ Theory.simpleGraph] :
    (simpleGraphOfStructure V).structure = S := by
  ext
  case funMap n f xs =>
    exact (IsRelational.empty_functions n).elim f
  case RelMap n r xs =>
    rw [iff_eq_eq]
    cases' n with n
    · exact r.elim
    · cases' n with n
      · exact r.elim
      · cases' n with n
        · cases r
          change RelMap adj ![xs 0, xs 1] = _
          refine' congr rfl (funext _)
          simp [Fin.forall_fin_two]
        · 

Proof state:
case succ.succ.succ
L : Language
α : Type w
V : Type w'
n✝ : ℕ
S : Structure Language.graph V
inst✝ : V ⊨ Theory.simpleGraph
n : ℕ
r : Relations Language.graph (Nat.succ (Nat.succ (Nat.succ n)))
xs : Fin (Nat.succ (Nat.succ (Nat.succ n))) → V
⊢ RelMap r xs = RelMap r xs

Next tactic:
exact r.elim
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    exact Quot.sound (add_zero_equiv x)
  zero_add := by
    rintro ⟨x⟩
    exact Quot.sound (zero_add_equiv x)
  add_assoc := by
    

Proof state:
⊢ ∀ (a b c : Game), a + b + c = a + (b + c)

Next tactic:
rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    exact Quot.sound (add_zero_equiv x)
  zero_add := by
    rintro ⟨x⟩
    exact Quot.sound (zero_add_equiv x)
  add_assoc := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    

Proof state:
case mk.mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
c✝ : Game
z : PGame
⊢ Quot.mk Setoid.r x + Quot.mk Setoid.r y + Quot.mk Setoid.r z =
    Quot.mk Setoid.r x + (Quot.mk Setoid.r y + Quot.mk Setoid.r z)

Next tactic:
exact Quot.sound add_assoc_equiv
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    exact Quot.sound (add_zero_equiv x)
  zero_add := by
    

Proof state:
⊢ ∀ (a : Game), 0 + a = a

Next tactic:
rintro ⟨x⟩
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    exact Quot.sound (add_zero_equiv x)
  zero_add := by
    rintro ⟨x⟩
    

Proof state:
case mk
a✝ : Game
x : PGame
⊢ 0 + Quot.mk Setoid.r x = Quot.mk Setoid.r x

Next tactic:
exact Quot.sound (zero_add_equiv x)
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    

Proof state:
⊢ ∀ (a : Game), a + 0 = a

Next tactic:
rintro ⟨x⟩
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    

Proof state:
case mk
a✝ : Game
x : PGame
⊢ Quot.mk Setoid.r x + 0 = Quot.mk Setoid.r x

Next tactic:
exact Quot.sound (add_zero_equiv x)
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    exact Quot.sound (add_zero_equiv x)
  zero_add := by
    rintro ⟨x⟩
    exact Quot.sound (zero_add_equiv x)
  add_assoc := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact Quot.sound add_assoc_equiv
  add_left_neg := by
    

Proof state:
⊢ ∀ (a : Game), -a + a = 0

Next tactic:
rintro ⟨x⟩
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    exact Quot.sound (add_zero_equiv x)
  zero_add := by
    rintro ⟨x⟩
    exact Quot.sound (zero_add_equiv x)
  add_assoc := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact Quot.sound add_assoc_equiv
  add_left_neg := by
    rintro ⟨x⟩
    

Proof state:
case mk
a✝ : Game
x : PGame
⊢ -Quot.mk Setoid.r x + Quot.mk Setoid.r x = 0

Next tactic:
exact Quot.sound (add_left_neg_equiv x)
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    exact Quot.sound (add_zero_equiv x)
  zero_add := by
    rintro ⟨x⟩
    exact Quot.sound (zero_add_equiv x)
  add_assoc := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact Quot.sound add_assoc_equiv
  add_left_neg := by
    rintro ⟨x⟩
    exact Quot.sound (add_left_neg_equiv x)
  add_comm := by
    

Proof state:
⊢ ∀ (a b : Game), a + b = b + a

Next tactic:
rintro ⟨x⟩ ⟨y⟩
instance instAddCommGroupWithOneGame : AddCommGroupWithOne Game where
  zero := ⟦0⟧
  one := ⟦1⟧
  neg := neg
  add :=
    Quotient.lift₂ (fun x y : PGame => ⟦x + y⟧) fun x₁ y₁ x₂ y₂ hx hy =>
      Quot.sound (PGame.add_congr hx hy)
  add_zero := by
    rintro ⟨x⟩
    exact Quot.sound (add_zero_equiv x)
  zero_add := by
    rintro ⟨x⟩
    exact Quot.sound (zero_add_equiv x)
  add_assoc := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact Quot.sound add_assoc_equiv
  add_left_neg := by
    rintro ⟨x⟩
    exact Quot.sound (add_left_neg_equiv x)
  add_comm := by
    rintro ⟨x⟩ ⟨y⟩
    

Proof state:
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x + Quot.mk Setoid.r y = Quot.mk Setoid.r y + Quot.mk Setoid.r x

Next tactic:
exact Quot.sound add_comm_equiv
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    

Proof state:
⊢ ∀ (a : Game), a ≤ a

Next tactic:
rintro ⟨x⟩
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    rintro ⟨x⟩
    

Proof state:
case mk
a✝ : Game
x : PGame
⊢ Quot.mk Setoid.r x ≤ Quot.mk Setoid.r x

Next tactic:
exact le_refl x
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    rintro ⟨x⟩
    exact le_refl x
  le_trans := by
    

Proof state:
⊢ ∀ (a b c : Game), a ≤ b → b ≤ c → a ≤ c

Next tactic:
rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    rintro ⟨x⟩
    exact le_refl x
  le_trans := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    

Proof state:
case mk.mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
c✝ : Game
z : PGame
⊢ Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y →
    Quot.mk Setoid.r y ≤ Quot.mk Setoid.r z → Quot.mk Setoid.r x ≤ Quot.mk Setoid.r z

Next tactic:
exact @le_trans _ _ x y z
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    rintro ⟨x⟩
    exact le_refl x
  le_trans := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact @le_trans _ _ x y z
  le_antisymm := by
    rintro ⟨x⟩ ⟨y⟩ h₁ h₂
    apply Quot.sound
    exact ⟨h₁, h₂⟩
  lt := Quotient.lift₂ (· < ·) fun x₁ y₁ x₂ y₂ hx hy => propext (lt_congr hx hy)
  lt_iff_le_not_le := by
    

Proof state:
⊢ ∀ (a b : Game), a < b ↔ a ≤ b ∧ ¬b ≤ a

Next tactic:
rintro ⟨x⟩ ⟨y⟩
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    rintro ⟨x⟩
    exact le_refl x
  le_trans := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact @le_trans _ _ x y z
  le_antisymm := by
    rintro ⟨x⟩ ⟨y⟩ h₁ h₂
    apply Quot.sound
    exact ⟨h₁, h₂⟩
  lt := Quotient.lift₂ (· < ·) fun x₁ y₁ x₂ y₂ hx hy => propext (lt_congr hx hy)
  lt_iff_le_not_le := by
    rintro ⟨x⟩ ⟨y⟩
    

Proof state:
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x < Quot.mk Setoid.r y ↔
    Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y ∧ ¬Quot.mk Setoid.r y ≤ Quot.mk Setoid.r x

Next tactic:
exact @lt_iff_le_not_le _ _ x y
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    rintro ⟨x⟩
    exact le_refl x
  le_trans := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact @le_trans _ _ x y z
  le_antisymm := by
    

Proof state:
⊢ ∀ (a b : Game), a ≤ b → b ≤ a → a = b

Next tactic:
rintro ⟨x⟩ ⟨y⟩ h₁ h₂
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    rintro ⟨x⟩
    exact le_refl x
  le_trans := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact @le_trans _ _ x y z
  le_antisymm := by
    rintro ⟨x⟩ ⟨y⟩ h₁ h₂
    

Proof state:
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
h₁ : Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y
h₂ : Quot.mk Setoid.r y ≤ Quot.mk Setoid.r x
⊢ Quot.mk Setoid.r x = Quot.mk Setoid.r y

Next tactic:
apply Quot.sound
instance instPartialOrderGame : PartialOrder Game where
  le := Quotient.lift₂ (· ≤ ·) fun x₁ y₁ x₂ y₂ hx hy => propext (le_congr hx hy)
  le_refl := by
    rintro ⟨x⟩
    exact le_refl x
  le_trans := by
    rintro ⟨x⟩ ⟨y⟩ ⟨z⟩
    exact @le_trans _ _ x y z
  le_antisymm := by
    rintro ⟨x⟩ ⟨y⟩ h₁ h₂
    apply Quot.sound
    

Proof state:
case mk.mk.a
a✝ : Game
x : PGame
b✝ : Game
y : PGame
h₁ : Quot.mk Setoid.r x ≤ Quot.mk Setoid.r y
h₂ : Quot.mk Setoid.r y ≤ Quot.mk Setoid.r x
⊢ Setoid.r x y

Next tactic:
exact ⟨h₁, h₂⟩
/-- On `Game`, simp-normal inequalities should use as few negations as possible. -/
@[simp]
theorem not_le : ∀ {x y : Game}, ¬x ≤ y ↔ y ⧏ x := by
  

Proof state:
⊢ ∀ {x y : Game}, ¬x ≤ y ↔ y ⧏ x

Next tactic:
rintro ⟨x⟩ ⟨y⟩
/-- On `Game`, simp-normal inequalities should use as few negations as possible. -/
@[simp]
theorem not_le : ∀ {x y : Game}, ¬x ≤ y ↔ y ⧏ x := by
  rintro ⟨x⟩ ⟨y⟩
  

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

Next tactic:
exact PGame.not_le
/-- On `Game`, simp-normal inequalities should use as few negations as possible. -/
@[simp]
theorem not_lf : ∀ {x y : Game}, ¬x ⧏ y ↔ y ≤ x := by
  

Proof state:
⊢ ∀ {x y : Game}, ¬x ⧏ y ↔ y ≤ x

Next tactic:
rintro ⟨x⟩ ⟨y⟩
/-- On `Game`, simp-normal inequalities should use as few negations as possible. -/
@[simp]
theorem not_lf : ∀ {x y : Game}, ¬x ⧏ y ↔ y ≤ x := by
  rintro ⟨x⟩ ⟨y⟩
  

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

Next tactic:
exact PGame.not_lf
instance : IsTrichotomous Game LF :=
  ⟨by
    

Proof state:
⊢ ∀ (a b : Game), a ⧏ b ∨ a = b ∨ b ⧏ a

Next tactic:
rintro ⟨x⟩ ⟨y⟩
instance : IsTrichotomous Game LF :=
  ⟨by
    rintro ⟨x⟩ ⟨y⟩
    

Proof state:
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x ⧏ Quot.mk Setoid.r y ∨
    Quot.mk Setoid.r x = Quot.mk Setoid.r y ∨ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x

Next tactic:
change _ ∨ ⟦x⟧ = ⟦y⟧ ∨ _
instance : IsTrichotomous Game LF :=
  ⟨by
    rintro ⟨x⟩ ⟨y⟩
    change _ ∨ ⟦x⟧ = ⟦y⟧ ∨ _
    

Proof state:
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x ⧏ Quot.mk Setoid.r y ∨ ⟦x⟧ = ⟦y⟧ ∨ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x

Next tactic:
rw [Quotient.eq]
instance : IsTrichotomous Game LF :=
  ⟨by
    rintro ⟨x⟩ ⟨y⟩
    change _ ∨ ⟦x⟧ = ⟦y⟧ ∨ _
    rw [Quotient.eq]
    

Proof state:
case mk.mk
a✝ : Game
x : PGame
b✝ : Game
y : PGame
⊢ Quot.mk Setoid.r x ⧏ Quot.mk Setoid.r y ∨ x ≈ y ∨ Quot.mk Setoid.r y ⧏ Quot.mk Setoid.r x

Next tactic:
apply lf_or_equiv_or_gf
instance covariantClass_add_le : CovariantClass Game Game (· + ·) (· ≤ ·) :=
  ⟨by
    

Proof state:
⊢ Covariant Game Game (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

Next tactic:
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
instance covariantClass_add_le : CovariantClass Game Game (· + ·) (· ≤ ·) :=
  ⟨by
    rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
    

Proof state:
case mk.mk.mk
m✝ : Game
a : PGame
n₁✝ : Game
b : PGame
n₂✝ : Game
c : PGame
h : Quot.mk Setoid.r b ≤ Quot.mk Setoid.r c
⊢ (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r b) ≤
    (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r c)

Next tactic:
exact @add_le_add_left _ _ _ _ b c h a
instance covariantClass_swap_add_le : CovariantClass Game Game (swap (· + ·)) (· ≤ ·) :=
  ⟨by
    

Proof state:
⊢ Covariant Game Game (swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

Next tactic:
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
instance covariantClass_swap_add_le : CovariantClass Game Game (swap (· + ·)) (· ≤ ·) :=
  ⟨by
    rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
    

Proof state:
case mk.mk.mk
m✝ : Game
a : PGame
n₁✝ : Game
b : PGame
n₂✝ : Game
c : PGame
h : Quot.mk Setoid.r b ≤ Quot.mk Setoid.r c
⊢ swap (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r b) ≤
    swap (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r c)

Next tactic:
exact @add_le_add_right _ _ _ _ b c h a
instance covariantClass_add_lt : CovariantClass Game Game (· + ·) (· < ·) :=
  ⟨by
    

Proof state:
⊢ Covariant Game Game (fun x x_1 => x + x_1) fun x x_1 => x < x_1

Next tactic:
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
instance covariantClass_add_lt : CovariantClass Game Game (· + ·) (· < ·) :=
  ⟨by
    rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h
    

Proof state:
case mk.mk.mk
m✝ : Game
a : PGame
n₁✝ : Game
b : PGame
n₂✝ : Game
c : PGame
h : Quot.mk Setoid.r b < Quot.mk Setoid.r c
⊢ (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r b) <
    (fun x x_1 => x + x_1) (Quot.mk Setoid.r a) (Quot.mk Setoid.r c)

Next tactic:
exact @add_lt_add_left _ _ _ _ b c h a
instance covariantClass_swap_add_lt : CovariantClass Game Game (swap (· + ·)) (· < ·) :=
  ⟨by
    

Proof state:
⊢ Covariant Game Game (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

Next tactic:
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩ h