File: Mathlib/SetTheory/Surreal/Multiplication.lean

full_name: Surreal.Multiplication.P1
code: /-- The nontrivial part of P1 in [SchleicherStoll] says that the left options of `x * y`
  are less than the right options, and this is the general form of these statements. -/
def P1 (x₁ x₂ x₃ y₁ y₂ y₃ : PGame) 
goal: Prop

full_name: Surreal.Multiplication.P2
code: /-- The proposition P2, without numericity assumptions. -/
def P2 (x₁ x₂ y : PGame) 
goal: Prop

full_name: Surreal.Multiplication.P3
code: /-- The proposition P3, without the `x₁ < x₂` and `y₁ < y₂` assumptions. -/
def P3 (x₁ x₂ y₁ y₂ : PGame) 
goal: Prop

full_name: Surreal.Multiplication.P4
code: /-- The proposition P4, without numericity assumptions. In the references, the second part of the
  conjunction is stated as `∀ j, P3 x₁ x₂ y (y.moveRight j)`, which is equivalent to our statement
  by `P3_comm` and `P3_neg`. We choose to state everything in terms of left options for uniform
  treatment. -/
def P4 (x₁ x₂ y : PGame) 
goal: Prop

full_name: Surreal.Multiplication.P24
code: /-- The conjunction of P2 and P4. -/
def P24 (x₁ x₂ y : PGame) : Prop 
goal: Prop

full_name: Surreal.Multiplication.P3_comm
code: lemma P3_comm : P3 x₁ x₂ y₁ y₂ ↔ P3 y₁ y₂ x₁ x₂ 
goal: Surreal.Multiplication.P3 x₁ x₂ y₁ y₂ ↔ Surreal.Multiplication.P3 y₁ y₂ x₁ x₂

full_name: Surreal.Multiplication.P3.trans
code: lemma P3.trans (h₁ : P3 x₁ x₂ y₁ y₂) (h₂ : P3 x₂ x₃ y₁ y₂) : P3 x₁ x₃ y₁ y₂ 
goal: Surreal.Multiplication.P3 x₁ x₃ y₁ y₂

full_name: Surreal.Multiplication.P3_neg
code: lemma P3_neg : P3 x₁ x₂ y₁ y₂ ↔ P3 (-x₂) (-x₁) y₁ y₂ 
goal: Surreal.Multiplication.P3 x₁ x₂ y₁ y₂ ↔ Surreal.Multiplication.P3 (-x₂) (-x₁) y₁ y₂

full_name: Surreal.Multiplication.P2_neg_left
code: lemma P2_neg_left : P2 x₁ x₂ y ↔ P2 (-x₂) (-x₁) y 
goal: Surreal.Multiplication.P2 x₁ x₂ y ↔ Surreal.Multiplication.P2 (-x₂) (-x₁) y

full_name: Surreal.Multiplication.P2_neg_right
code: lemma P2_neg_right : P2 x₁ x₂ y ↔ P2 x₁ x₂ (-y) 
goal: Surreal.Multiplication.P2 x₁ x₂ y ↔ Surreal.Multiplication.P2 x₁ x₂ (-y)

full_name: Surreal.Multiplication.P4_neg_left
code: lemma P4_neg_left : P4 x₁ x₂ y ↔ P4 (-x₂) (-x₁) y 
goal: Surreal.Multiplication.P4 x₁ x₂ y ↔ Surreal.Multiplication.P4 (-x₂) (-x₁) y

full_name: Surreal.Multiplication.P4_neg_right
code: lemma P4_neg_right : P4 x₁ x₂ y ↔ P4 x₁ x₂ (-y) 
goal: Surreal.Multiplication.P4 x₁ x₂ y ↔ Surreal.Multiplication.P4 x₁ x₂ (-y)

full_name: Surreal.Multiplication.P24_neg_left
code: lemma P24_neg_left : P24 x₁ x₂ y ↔ P24 (-x₂) (-x₁) y 
goal: Surreal.Multiplication.P24 x₁ x₂ y ↔ Surreal.Multiplication.P24 (-x₂) (-x₁) y

full_name: Surreal.Multiplication.P24_neg_right
code: lemma P24_neg_right : P24 x₁ x₂ y ↔ P24 x₁ x₂ (-y) 
goal: Surreal.Multiplication.P24 x₁ x₂ y ↔ Surreal.Multiplication.P24 x₁ x₂ (-y)

full_name: Surreal.Multiplication.mulOption_lt_iff_P1
code: lemma mulOption_lt_iff_P1 {i j k l} :
    (⟦mulOption x y i k⟧ : Game) < -⟦mulOption x (-y) j l⟧ ↔
    P1 (x.moveLeft i) x (x.moveLeft j) y (y.moveLeft k) (-(-y).moveLeft l) 
goal: ⟦x.mulOption y i k⟧ < -⟦x.mulOption (-y) j l⟧ ↔
  Surreal.Multiplication.P1 (x.moveLeft i) x (x.moveLeft j) y (y.moveLeft k) (-(-y).moveLeft l)

full_name: Surreal.Multiplication.mulOption_lt_mul_iff_P3
code: lemma mulOption_lt_mul_iff_P3 {i j} :
    ⟦mulOption x y i j⟧ < (⟦x * y⟧ : Game) ↔ P3 (x.moveLeft i) x (y.moveLeft j) y 
goal: ⟦x.mulOption y i j⟧ < ⟦x * y⟧ ↔ Surreal.Multiplication.P3 (x.moveLeft i) x (y.moveLeft j) y

full_name: Surreal.Multiplication.P1_of_eq
code: lemma P1_of_eq (he : x₁ ≈ x₃) (h₁ : P2 x₁ x₃ y₁) (h₃ : P2 x₁ x₃ y₃) (h3 : P3 x₁ x₂ y₂ y₃) :
    P1 x₁ x₂ x₃ y₁ y₂ y₃ 
goal: Surreal.Multiplication.P1 x₁ x₂ x₃ y₁ y₂ y₃

full_name: Surreal.Multiplication.P1_of_lt
code: lemma P1_of_lt (h₁ : P3 x₃ x₂ y₂ y₃) (h₂ : P3 x₁ x₃ y₂ y₁) : P1 x₁ x₂ x₃ y₁ y₂ y₃ 
goal: Surreal.Multiplication.P1 x₁ x₂ x₃ y₁ y₂ y₃

full_name: Surreal.Multiplication.Args.P1
code: /-- The type of lists of arguments for P1, P2, and P4. -/
inductive Args : Type (u+1)
  | P1 (x y : PGame.{u}) : Args
  | P24 (x₁ x₂ y : PGame.{u}) : Args
goal: Surreal.Multiplication.Args

full_name: Surreal.Multiplication.Args
code: /-- The type of lists of arguments for P1, P2, and P4. -/
inductive Args : Type (u+1)
  | P1 (x y : PGame.{u}) : Args
  | P24 (x₁ x₂ y : PGame.{u}) : Args
goal: Type (u + 1)

full_name: Surreal.Multiplication.Args.P24
code: /-- The type of lists of arguments for P1, P2, and P4. -/
inductive Args : Type (u+1)
  | P1 (x y : PGame.{u}) : Args
  | P24 (x₁ x₂ y : PGame.{u}) : Args
goal: Surreal.Multiplication.Args

full_name: Surreal.Multiplication.Args.toMultiset
code: /-- The multiset associated to a list of arguments. -/
def Args.toMultiset : Args → Multiset PGame
  
goal: Surreal.Multiplication.Args → Multiset SetTheory.PGame

full_name: Surreal.Multiplication.Args.Numeric
code: /-- A list of arguments is numeric if all the arguments are. -/
def Args.Numeric (a : Args) 
goal: Prop

full_name: Surreal.Multiplication.Args.numeric_P1
code: lemma Args.numeric_P1 {x y} : (Args.P1 x y).Numeric ↔ x.Numeric ∧ y.Numeric 
goal: (Surreal.Multiplication.Args.P1 x y).Numeric ↔ x.Numeric ∧ y.Numeric

full_name: Surreal.Multiplication.Args.numeric_P24
code: lemma Args.numeric_P24 {x₁ x₂ y} :
    (Args.P24 x₁ x₂ y).Numeric ↔ x₁.Numeric ∧ x₂.Numeric ∧ y.Numeric 
goal: (Surreal.Multiplication.Args.P24 x₁ x₂ y).Numeric ↔ x₁.Numeric ∧ x₂.Numeric ∧ y.Numeric

full_name: Surreal.Multiplication.ArgsRel
code: /-- The relation specifying when a list of (pregame) arguments is considered simpler than another:
  `ArgsRel a₁ a₂` is true if `a₁`, considered as a multiset, can be obtained from `a₂` by
  repeatedly removing a pregame from `a₂` and adding back one or two options of the pregame.  -/
def ArgsRel 
goal: Surreal.Multiplication.Args → Surreal.Multiplication.Args → Prop

full_name: Surreal.Multiplication.argsRel_wf
code: /-- `ArgsRel` is well-founded. -/
theorem argsRel_wf : WellFounded ArgsRel 
goal: WellFounded Surreal.Multiplication.ArgsRel

full_name: Surreal.Multiplication.P124
code: /-- The statement that we will show by induction using the well-founded relation `ArgsRel`. -/
def P124 : Args → Prop
  
goal: Surreal.Multiplication.Args → Prop

full_name: Surreal.Multiplication.ArgsRel.numeric_closed
code: /-- The property that all arguments are numeric is leftward-closed under `ArgsRel`. -/
lemma ArgsRel.numeric_closed {a' a} : ArgsRel a' a → a.Numeric → a'.Numeric 
goal: Surreal.Multiplication.ArgsRel a' a → a.Numeric → a'.Numeric

full_name: Surreal.Multiplication.IH1
code: /-- A specialized induction hypothesis used to prove P1. -/
def IH1 (x y : PGame) : Prop 
goal: Prop

full_name: Surreal.Multiplication.ih1_neg_left
code: lemma ih1_neg_left : IH1 x y → IH1 (-x) y 
goal: Surreal.Multiplication.IH1 x y → Surreal.Multiplication.IH1 (-x) y

full_name: Surreal.Multiplication.ih1_neg_right
code: lemma ih1_neg_right : IH1 x y → IH1 x (-y) 
goal: Surreal.Multiplication.IH1 x y → Surreal.Multiplication.IH1 x (-y)

full_name: Surreal.Multiplication.numeric_option_mul
code: lemma numeric_option_mul (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (h : IsOption x' x) :
    (x' * y).Numeric 
goal: (x' * y).Numeric

full_name: Surreal.Multiplication.numeric_mul_option
code: lemma numeric_mul_option (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (h : IsOption y' y) :
    (x * y').Numeric 
goal: (x * y').Numeric

full_name: Surreal.Multiplication.numeric_option_mul_option
code: lemma numeric_option_mul_option (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (hx : IsOption x' x)
    (hy : IsOption y' y) : (x' * y').Numeric 
goal: (x' * y').Numeric

full_name: Surreal.Multiplication.ih1
code: lemma ih1 (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) : IH1 x y 
goal: Surreal.Multiplication.IH1 x y

full_name: Surreal.Multiplication.ih1_swap
code: lemma ih1_swap (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) : IH1 y x 
goal: Surreal.Multiplication.IH1 y x

full_name: Surreal.Multiplication.P3_of_ih
code: lemma P3_of_ih (hy : Numeric y) (ihyx : IH1 y x) (i k l) :
    P3 (x.moveLeft i) x (y.moveLeft k) (-(-y).moveLeft l) 
goal: Surreal.Multiplication.P3 (x.moveLeft i) x (y.moveLeft k) (-(-y).moveLeft l)

full_name: Surreal.Multiplication.P24_of_ih
code: lemma P24_of_ih (ihxy : IH1 x y) (i j) : P24 (x.moveLeft i) (x.moveLeft j) y 
goal: Surreal.Multiplication.P24 (x.moveLeft i) (x.moveLeft j) y

full_name: Surreal.Multiplication.mulOption_lt_of_lt
code: lemma mulOption_lt_of_lt (hy : y.Numeric) (ihxy : IH1 x y) (ihyx : IH1 y x) (i j k l)
    (h : x.moveLeft i < x.moveLeft j) :
    (⟦mulOption x y i k⟧ : Game) < -⟦mulOption x (-y) j l⟧ 
goal: ⟦x.mulOption y i k⟧ < -⟦x.mulOption (-y) j l⟧

full_name: Surreal.Multiplication.mulOption_lt
code: lemma mulOption_lt (hx : x.Numeric) (hy : y.Numeric) (ihxy : IH1 x y) (ihyx : IH1 y x) (i j k l) :
    (⟦mulOption x y i k⟧ : Game) < -⟦mulOption x (-y) j l⟧ 
goal: ⟦x.mulOption y i k⟧ < -⟦x.mulOption (-y) j l⟧

full_name: Surreal.Multiplication.P1_of_ih
code: /-- P1 follows from the induction hypothesis. -/
theorem P1_of_ih (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (hx : x.Numeric) (hy : y.Numeric) :
    (x * y).Numeric 
goal: (x * y).Numeric

full_name: Surreal.Multiplication.IH24
code: /-- A specialized induction hypothesis used to prove P2 and P4. -/
def IH24 (x₁ x₂ y : PGame) : Prop 
goal: Prop

full_name: Surreal.Multiplication.IH4
code: /-- A specialized induction hypothesis used to prove P4. -/
def IH4 (x₁ x₂ y : PGame) : Prop 
goal: Prop

full_name: Surreal.Multiplication.ih₁₂
code: lemma ih₁₂ (ih' : ∀ a, ArgsRel a (Args.P24 x₁ x₂ y) → P124 a) : IH24 x₁ x₂ y 
goal: Surreal.Multiplication.IH24 x₁ x₂ y

full_name: Surreal.Multiplication.ih₂₁
code: lemma ih₂₁ (ih' : ∀ a, ArgsRel a (Args.P24 x₁ x₂ y) → P124 a) : IH24 x₂ x₁ y 
goal: Surreal.Multiplication.IH24 x₂ x₁ y

full_name: Surreal.Multiplication.ih4
code: lemma ih4 (ih' : ∀ a, ArgsRel a (Args.P24 x₁ x₂ y) → P124 a) : IH4 x₁ x₂ y 
goal: Surreal.Multiplication.IH4 x₁ x₂ y

full_name: Surreal.Multiplication.numeric_of_ih
code: lemma numeric_of_ih (ih' : ∀ a, ArgsRel a (Args.P24 x₁ x₂ y) → P124 a) :
    (x₁ * y).Numeric ∧ (x₂ * y).Numeric 
goal: (x₁ * y).Numeric ∧ (x₂ * y).Numeric

full_name: Surreal.Multiplication.ih24_neg
code: /-- Symmetry properties of `IH24`. -/
lemma ih24_neg : IH24 x₁ x₂ y → IH24 (-x₂) (-x₁) y ∧ IH24 x₁ x₂ (-y) 
goal: Surreal.Multiplication.IH24 x₁ x₂ y → Surreal.Multiplication.IH24 (-x₂) (-x₁) y ∧ Surreal.Multiplication.IH24 x₁ x₂ (-y)

full_name: Surreal.Multiplication.ih4_neg
code: /-- Symmetry properties of `IH4`. -/
lemma ih4_neg : IH4 x₁ x₂ y → IH4 (-x₂) (-x₁) y ∧ IH4 x₁ x₂ (-y) 
goal: Surreal.Multiplication.IH4 x₁ x₂ y → Surreal.Multiplication.IH4 (-x₂) (-x₁) y ∧ Surreal.Multiplication.IH4 x₁ x₂ (-y)

full_name: Surreal.Multiplication.mulOption_lt_mul_of_equiv
code: lemma mulOption_lt_mul_of_equiv (hn : x₁.Numeric) (h : IH24 x₁ x₂ y) (he : x₁ ≈ x₂) (i j) :
    ⟦mulOption x₁ y i j⟧ < (⟦x₂ * y⟧ : Game) 
goal: ⟦x₁.mulOption y i j⟧ < ⟦x₂ * y⟧

full_name: Surreal.Multiplication.mul_right_le_of_equiv
code: /-- P2 follows from specialized induction hypotheses (one half of the equality). -/
theorem mul_right_le_of_equiv (h₁ : x₁.Numeric) (h₂ : x₂.Numeric)
    (h₁₂ : IH24 x₁ x₂ y) (h₂₁ : IH24 x₂ x₁ y) (he : x₁ ≈ x₂) : x₁ * y ≤ x₂ * y 
goal: x₁ * y ≤ x₂ * y

full_name: Surreal.Multiplication.MulOptionsLTMul
code: /-- The statement that all left options of `x * y` of the first kind are less than itself. -/
def MulOptionsLTMul (x y : PGame) : Prop 
goal: Prop

full_name: Surreal.Multiplication.mulOptionsLTMul_of_numeric
code: /-- That the left options of `x * y` are less than itself and the right options are greater, which
  is part of the condition that `x * y` is numeric, is equivalent to the conjunction of various
  `MulOptionsLTMul` statements for `x`, `y` and their negations. We only show the forward
  direction. -/
lemma mulOptionsLTMul_of_numeric (hn : (x * y).Numeric) :
    (MulOptionsLTMul x y ∧ MulOptionsLTMul (-x) (-y)) ∧
    (MulOptionsLTMul x (-y) ∧ MulOptionsLTMul (-x) y) 
goal: (Surreal.Multiplication.MulOptionsLTMul x y ∧ Surreal.Multiplication.MulOptionsLTMul (-x) (-y)) ∧
  Surreal.Multiplication.MulOptionsLTMul x (-y) ∧ Surreal.Multiplication.MulOptionsLTMul (-x) y

full_name: Surreal.Multiplication.IH3
code: /-- A condition just enough to deduce P3, which will always be used with `x'` being a left
  option of `x₂`. When `y₁` is a left option of `y₂`, it can be deduced from induction hypotheses
  `IH24 x₁ x₂ y₂`, `IH4 x₁ x₂ y₂`, and `(x₂ * y₂).Numeric` (`ih3_of_ih`); when `y₁` is
  not necessarily an option of `y₂`, it follows from the induction hypothesis for P3 (with `x₂`
  replaced by a left option `x'`) after the `main` theorem (P124) is established, and is used to
  prove P3 in full (`P3_of_lt_of_lt`). -/
def IH3 (x₁ x' x₂ y₁ y₂ : PGame) : Prop 
goal: Prop

full_name: Surreal.Multiplication.ih3_of_ih
code: lemma ih3_of_ih (h24 : IH24 x₁ x₂ y) (h4 : IH4 x₁ x₂ y) (hl : MulOptionsLTMul x₂ y) (i j) :
    IH3 x₁ (x₂.moveLeft i) x₂ (y.moveLeft j) y 
goal: Surreal.Multiplication.IH3 x₁ (x₂.moveLeft i) x₂ (y.moveLeft j) y

full_name: Surreal.Multiplication.P3_of_le_left
code: lemma P3_of_le_left {y₁ y₂} (i) (h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂) (hl : x₁ ≤ x₂.moveLeft i) :
    P3 x₁ x₂ y₁ y₂ 
goal: Surreal.Multiplication.P3 x₁ x₂ y₁ y₂

full_name: Surreal.Multiplication.P3_of_lt
code: /-- P3 follows from `IH3` (so P4 (with `y₁` a left option of `y₂`) follows from the induction
  hypothesis). -/
theorem P3_of_lt {y₁ y₂} (h : ∀ i, IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂)
    (hs : ∀ i, IH3 (-x₂) ((-x₁).moveLeft i) (-x₁) y₁ y₂) (hl : x₁ < x₂) :
    P3 x₁ x₂ y₁ y₂ 
goal: Surreal.Multiplication.P3 x₁ x₂ y₁ y₂

full_name: Surreal.Multiplication.main
code: /-- The main chunk of Theorem 8 in [Conway2001] / Theorem 3.8 in [SchleicherStoll]. -/
theorem main (a : Args) : a.Numeric → P124 a 
goal: a.Numeric → Surreal.Multiplication.P124 a

full_name: SetTheory.PGame.Numeric.mul
code: theorem Numeric.mul : Numeric (x * y) 
goal: (x * y).Numeric

full_name: SetTheory.PGame.P24
code: theorem P24 : P24 x₁ x₂ y 
goal: Surreal.Multiplication.P24 x₁ x₂ y

full_name: SetTheory.PGame.Equiv.mul_congr_left
code: theorem Equiv.mul_congr_left (he : x₁ ≈ x₂) : x₁ * y ≈ x₂ * y 
goal: x₁ * y ≈ x₂ * y

full_name: SetTheory.PGame.Equiv.mul_congr_right
code: theorem Equiv.mul_congr_right (he : y₁ ≈ y₂) : x * y₁ ≈ x * y₂ 
goal: x * y₁ ≈ x * y₂

full_name: SetTheory.PGame.Equiv.mul_congr
code: theorem Equiv.mul_congr (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ * y₁ ≈ x₂ * y₂ 
goal: x₁ * y₁ ≈ x₂ * y₂

full_name: SetTheory.PGame.P3_of_lt_of_lt
code: /-- One additional inductive argument that supplies the last missing part of Theorem 8. -/
theorem P3_of_lt_of_lt (hx : x₁ < x₂) (hy : y₁ < y₂) : P3 x₁ x₂ y₁ y₂ 
goal: Surreal.Multiplication.P3 x₁ x₂ y₁ y₂

full_name: SetTheory.PGame.Numeric.mul_pos
code: theorem Numeric.mul_pos (hp₁ : 0 < x₁) (hp₂ : 0 < x₂) : 0 < x₁ * x₂ 
goal: 0 < x₁ * x₂

full_name: Surreal.instLinearOrderedCommRing
code: noncomputable instance : LinearOrderedCommRing Surreal 
goal: LinearOrderedCommRing Surreal