l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> 

Proof state:
case refine'_2.left_inv.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
fst✝ : xl
val✝ : yr
⊢ (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)))
        (Sum.inl (fst✝, Sum.inl val✝))) =
    Sum.inl (fst✝, Sum.inl val✝)

Next tactic:
rfl
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> 

Proof state:
case refine'_2.left_inv.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
fst✝ : xl
val✝ : 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)))
        (Sum.inl (fst✝, Sum.inr val✝))) =
    Sum.inl (fst✝, Sum.inr val✝)

Next tactic:
rfl
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> 

Proof state:
case refine'_2.left_inv.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
fst✝ : xr
val✝ : yl
⊢ (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)))
        (Sum.inr (fst✝, Sum.inl val✝))) =
    Sum.inr (fst✝, Sum.inl val✝)

Next tactic:
rfl
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> 

Proof state:
case refine'_2.left_inv.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
fst✝ : xr
val✝ : zl
⊢ (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)))
        (Sum.inr (fst✝, Sum.inr val✝))) =
    Sum.inr (fst✝, Sum.inr val✝)

Next tactic:
rfl
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · 

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

Next tactic:
rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩)
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> 

Proof state:
case refine'_2.right_inv.inl.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
fst✝ : xl
snd✝ : yr
⊢ (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))
        (Sum.inl (Sum.inl (fst✝, snd✝)))) =
    Sum.inl (Sum.inl (fst✝, snd✝))

Next tactic:
rfl
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> 

Proof state:
case refine'_2.right_inv.inl.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
fst✝ : xr
snd✝ : yl
⊢ (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))
        (Sum.inl (Sum.inr (fst✝, snd✝)))) =
    Sum.inl (Sum.inr (fst✝, snd✝))

Next tactic:
rfl
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> 

Proof state:
case refine'_2.right_inv.inr.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
fst✝ : xl
snd✝ : 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))
        (Sum.inr (Sum.inl (fst✝, snd✝)))) =
    Sum.inr (Sum.inl (fst✝, snd✝))

Next tactic:
rfl
@[simp]
theorem quot_left_distrib (x y z : PGame) : (⟦x * (y + z)⟧ : Game) = ⟦x * y⟧ + ⟦x * z⟧ :=
  match x, y, z with
  | mk xl xr xL xR, mk yl yr yL yR, mk zl zr zL zR => by
    let x := mk xl xr xL xR
    let y := mk yl yr yL yR
    let z := mk zl zr zL zR
    refine' quot_eq_of_mk'_quot_eq _ _ _ _
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          -- Porting note: we've increased `maxDepth` here from `5` to `6`.
          -- Likely this sort of off-by-one error is just a change in the implementation
          -- of `solve_by_elim`.
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> rfl
    · fconstructor
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;>
          solve_by_elim (config := { maxDepth := 6 }) [Sum.inl, Sum.inr, Prod.mk]
      · rintro (⟨_, _ | _⟩ | ⟨_, _ | _⟩) <;> rfl
      · rintro (⟨⟨_, _⟩ | ⟨_, _⟩⟩ | ⟨_, _⟩ | ⟨_, _⟩) <;> 

Proof state:
case refine'_2.right_inv.inr.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
fst✝ : xr
snd✝ : zl
⊢ (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))
        (Sum.inr (Sum.inr (fst✝, snd✝)))) =
    Sum.inr (Sum.inr (fst✝, snd✝))

Next tactic:
rfl