Skip to content

Instantly share code, notes, and snippets.

@semorrison

semorrison/gist:56f6f878a3d60d8aaee93184146fff08

Created August 24, 2019 07:09
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save semorrison/56f6f878a3d60d8aaee93184146fff08 to your computer and use it in GitHub Desktop.
Save semorrison/56f6f878a3d60d8aaee93184146fff08 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gistfile1.txt
@decidable.rec
(∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b) (λ (a b : ℤ), int.decidable_eq a b) a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x) y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame))
(λ
(_x :
decidable
(∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame))),
decidable
((∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)) ∧
∀ (j : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame j))
(λ
(hp :
¬∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)),
@is_false
((∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)) ∧
∀ (j : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame j)
_)
(λ
(hp :
∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b) (λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x) y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)),
@dite
(∀ (j : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame j)
(@fintype.decidable_forall_fintype pempty
(@pgame.fintype_right punit pempty (λ (_x : punit), 0) (@pempty.elim pgame) pgame.short_1)
(λ (a : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame a)
(@id
(@decidable_pred pempty
(λ (a : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame a))
(λ (i : pempty),
@prod.snd
(decidable
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) ≤
@pempty.elim pgame i))
(decidable
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame i))
((λ (y : Σ' (x y : pgame) [_inst_1 : short x], short y)
(a :
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame (λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1) (short.has_sizeof_inst a_1)))))
y
x)
y
(@psigma.mk pgame
(λ (a : pgame),
(λ (a : pgame), (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y) a) a)
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))
(@psigma.mk pgame
(λ (a : pgame),
(λ (a : pgame),
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))],
short y)
a)
a)
(mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame))
(@psigma.mk
(short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)))
(λ
(a :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))),
(λ
(a :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))),
@(λ
[_inst_1 :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))],
short (mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)))
a)
a)
domineering.L.pgame.short
pgame.short_1)))),
@acc.rec (Σ' (x y : pgame) [_inst_1 : short x], short y)
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame (λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1) (short.has_sizeof_inst a_1)))))
y
x)
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)) ×
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y) _x <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)))
_x)
(λ (x₁ : Σ' (x y : pgame) [_inst_1 : short x], short y)
(ac₁ :
∀ (y : Σ' (x y : pgame) [_inst_1 : short x], short y),
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
y
x)
y
x₁ →
@acc (Σ' (x y : pgame) [_inst_1 : short x], short y)
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
y
x)
y)
(ih :
Π (y : Σ' (x y : pgame) [_inst_1 : short x], short y),
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
y
x)
y
x₁ →
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)) ×
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)))
y),
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@psigma.cases_on pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
_x →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)) ×
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)))
_x
(λ (fst : pgame) (snd : Σ' (y : pgame) [_inst_1 : short fst], short y),
@pgame.cases_on
(λ (fst : pgame),
Π (snd : Σ' (y : pgame) [_inst_1 : short fst], short y),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd) ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd))],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd))) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd) <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd))],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd))))
fst
(λ (fst_α fst_β : Type) (fst_a : fst_α → pgame) (fst_a_1 : fst_β → pgame)
(snd :
Σ' (y : pgame) [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)], short y),
@psigma.cases_on pgame
(λ (y : pgame),
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)], short y)
(λ
(snd :
Σ' (y : pgame) [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short y),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd) ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd))],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd))) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd) <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd))],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd))))
snd
(λ (snd_fst : pgame)
(snd_snd :
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)], short snd_fst),
@pgame.cases_on
(λ (snd_fst : pgame),
Π
(snd_snd :
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short snd_fst),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r
(Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)) ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short y)
snd_fst
snd_snd)))],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)))) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)) <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short y)
snd_fst
snd_snd)))],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)))))
snd_fst
(λ (snd_fst_α snd_fst_β : Type) (snd_fst_a : snd_fst_α → pgame)
(snd_fst_a_1 : snd_fst_β → pgame)
(snd_snd :
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short (mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)),
@psigma.cases_on (short (mk fst_α fst_β fst_a fst_a_1))
(λ [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short (mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
(λ
(snd_snd :
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short (mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r
(Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
snd_snd)) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
snd_snd)) ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
snd_snd)))],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
snd_snd)))) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
snd_snd)) <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
snd_snd)))],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
snd_snd)))))
snd_snd
(λ (snd_snd_fst : short (mk fst_α fst_β fst_a fst_a_1))
(snd_snd_snd :
short (mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)),
id_rhs
((Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r
(Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame),
Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof
(short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(@psigma.mk
(short (mk fst_α fst_β fst_a fst_a_1))
(λ
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
snd_snd_fst
snd_snd_snd))) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame)
[_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame)
[_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y))) →
decidable
(mk fst_α fst_β fst_a fst_a_1 ≤
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1) ×
decidable
(mk fst_α fst_β fst_a fst_a_1 <
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
(λ
(_F :
Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r
(Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame),
Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof
(short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(@psigma.mk
(short (mk fst_α fst_β fst_a fst_a_1))
(λ
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
snd_snd_fst
snd_snd_snd))) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame)
[_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame)
[_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y))),
(@eq.mpr
(decidable
(mk fst_α fst_β fst_a fst_a_1 ≤
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
(decidable
((∀ (i : fst_α),
fst_a i <
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1) ∧
∀ (j : snd_fst_β),
mk fst_α fst_β fst_a fst_a_1 < snd_fst_a_1 j))
_
(@and.decidable
(∀ (i : fst_α),
fst_a i <
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(∀ (j : snd_fst_β),
mk fst_α fst_β fst_a fst_a_1 < snd_fst_a_1 j)
(@fintype.decidable_forall_fintype fst_α
(@pgame.fintype_left fst_α fst_β fst_a fst_a_1
snd_snd_fst)
(λ (a : fst_α),
fst_a a <
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
(@id
(@decidable_pred fst_α
(λ (a : fst_α),
fst_a a <
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(λ (i : fst_α),
@prod.snd
(decidable
(fst_a i ≤
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(decidable
(fst_a i <
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(_F
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame)
[_inst_1 : short x],
short y)
(fst_a i)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 : short (fst_a i)],
short y)
(mk snd_fst_α snd_fst_β
snd_fst_a
snd_fst_a_1)
(@psigma.mk (short (fst_a i))
(λ
[_inst_1 : short (fst_a i)],
short
(mk snd_fst_α snd_fst_β
snd_fst_a
snd_fst_a_1))
(@pgame.move_left_short' fst_α
fst_β
fst_a
fst_a_1
snd_snd_fst
i)
snd_snd_snd)))
_))))
(@fintype.decidable_forall_fintype snd_fst_β
(@pgame.fintype_right snd_fst_α snd_fst_β
snd_fst_a
snd_fst_a_1
snd_snd_snd)
(λ (a : snd_fst_β),
mk fst_α fst_β fst_a fst_a_1 < snd_fst_a_1 a)
(@id
(@decidable_pred snd_fst_β
(λ (a : snd_fst_β),
mk fst_α fst_β fst_a fst_a_1 <
snd_fst_a_1 a))
(λ (i : snd_fst_β),
@prod.snd
(decidable
(mk fst_α fst_β fst_a fst_a_1 ≤
snd_fst_a_1 i))
(decidable
(mk fst_α fst_β fst_a fst_a_1 <
snd_fst_a_1 i))
(_F
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame)
[_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short y)
(snd_fst_a_1 i)
(@psigma.mk
(short
(mk fst_α fst_β fst_a
fst_a_1))
(λ
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short (snd_fst_a_1 i))
snd_snd_fst
(@pgame.move_right_short'
snd_fst_α
snd_fst_β
snd_fst_a
snd_fst_a_1
snd_snd_snd
i))))
_))))),
@eq.mpr
(decidable
(mk fst_α fst_β fst_a fst_a_1 <
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
(decidable
((∃ (i : snd_fst_α),
mk fst_α fst_β fst_a fst_a_1 ≤
snd_fst_a i) ∨
∃ (j : fst_β),
fst_a_1 j ≤
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
_
(@or.decidable
(∃ (i : snd_fst_α),
mk fst_α fst_β fst_a fst_a_1 ≤ snd_fst_a i)
(∃ (j : fst_β),
fst_a_1 j ≤
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(@fintype.decidable_exists_fintype snd_fst_α
(@pgame.fintype_left snd_fst_α snd_fst_β
snd_fst_a
snd_fst_a_1
snd_snd_snd)
(λ (a : snd_fst_α),
mk fst_α fst_β fst_a fst_a_1 ≤ snd_fst_a a)
(@id
(@decidable_pred snd_fst_α
(λ (a : snd_fst_α),
mk fst_α fst_β fst_a fst_a_1 ≤
snd_fst_a a))
(λ (i : snd_fst_α),
@prod.fst
(decidable
(mk fst_α fst_β fst_a fst_a_1 ≤
snd_fst_a i))
(decidable
(mk fst_α fst_β fst_a fst_a_1 <
snd_fst_a i))
(_F
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame)
[_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short y)
(snd_fst_a i)
(@psigma.mk
(short
(mk fst_α fst_β fst_a
fst_a_1))
(λ
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short (snd_fst_a i))
snd_snd_fst
(@pgame.move_left_short'
snd_fst_α
snd_fst_β
snd_fst_a
snd_fst_a_1
snd_snd_snd
i))))
_))))
(@fintype.decidable_exists_fintype fst_β
(@pgame.fintype_right fst_α fst_β fst_a fst_a_1
snd_snd_fst)
(λ (a : fst_β),
fst_a_1 a ≤
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
(@id
(@decidable_pred fst_β
(λ (a : fst_β),
fst_a_1 a ≤
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(λ (i : fst_β),
@prod.fst
(decidable
(fst_a_1 i ≤
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(decidable
(fst_a_1 i <
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(_F
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame)
[_inst_1 : short x],
short y)
(fst_a_1 i)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (fst_a_1 i)],
short y)
(mk snd_fst_α snd_fst_β
snd_fst_a
snd_fst_a_1)
(@psigma.mk (short (fst_a_1 i))
(λ
[_inst_1 : short (fst_a_1 i)],
short
(mk snd_fst_α snd_fst_β
snd_fst_a
snd_fst_a_1))
(@pgame.move_right_short'
fst_α
fst_β
fst_a
fst_a_1
snd_snd_fst
i)
snd_snd_snd)))
_)))))))))
snd_snd))
snd))
x₁
ih)
y
_)
(@psigma.mk pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))],
short y)
(@pempty.elim pgame i)
(@psigma.mk
(short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)))
(λ
[_inst_1 :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))], short (@pempty.elim pgame i))
domineering.L.pgame.short
(@pgame.move_right_short' punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)
pgame.short_1
i))))
_))))
(decidable
((∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)) ∧
∀ (j : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame j))
(λ
(hq :
∀ (j : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame j),
@is_true
((∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)) ∧
∀ (j : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame j)
_)
(λ
(hq :
¬∀ (j : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame j),
@is_false
((∀
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)) ∧
∀ (j : pempty),
mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_) <
@pempty.elim pgame j)
_))
(@fintype.decidable_forall_fintype
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b) (λ (a b : ℤ), int.decidable_eq a b) a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(@pgame.fintype_left
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x) y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x) y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
domineering.L.pgame.short)
(λ
(a :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b) (λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)), @has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) < @finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
a <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame))
(@id
(@decidable_pred
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(a :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x → pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
a <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)))
(λ
(i :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@prod.snd
(decidable
((λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i ≤
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)))
(decidable
((λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i <
mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)))
((λ (y : Σ' (x y : pgame) [_inst_1 : short x], short y)
(a :
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame (λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1) (short.has_sizeof_inst a_1)))))
y
x)
y
(@psigma.mk pgame
(λ (a : pgame),
(λ (a : pgame), (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y) a) a)
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))
(@psigma.mk pgame
(λ (a : pgame),
(λ (a : pgame),
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))],
short y)
a)
a)
(mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame))
(@psigma.mk
(short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)))
(λ
(a :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))),
(λ
(a :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))),
@(λ
[_inst_1 :
short
(mk
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y
x)
(λ (_x : finset (ℤ × ℤ)),
(λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
y
x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ))
finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ
(λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_))], short (mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)))
a)
a)
domineering.L.pgame.short
pgame.short_1)))),
@acc.rec (Σ' (x y : pgame) [_inst_1 : short x], short y)
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame (λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1) (short.has_sizeof_inst a_1)))))
y
x)
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y) _x ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)) ×
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y) _x <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)))
_x)
(λ (x₁ : Σ' (x y : pgame) [_inst_1 : short x], short y)
(ac₁ :
∀ (y : Σ' (x y : pgame) [_inst_1 : short x], short y),
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame (λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1) (short.has_sizeof_inst a_1)))))
y
x)
y
x₁ →
@acc (Σ' (x y : pgame) [_inst_1 : short x], short y)
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame (λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
y
x)
y)
(ih :
Π (y : Σ' (x y : pgame) [_inst_1 : short x], short y),
(λ (y x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame (λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1) (short.has_sizeof_inst a_1)))))
y
x)
y
x₁ →
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y) _x ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)) ×
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y) _x <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)))
y),
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
@psigma.cases_on pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(λ (_x : Σ' (x y : pgame) [_inst_1 : short x], short y),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a) (λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a) (short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
_x →
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)) ×
decidable
(@psigma.fst pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y) _x <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)],
short y)
(@psigma.snd pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_x)))
_x
(λ (fst : pgame) (snd : Σ' (y : pgame) [_inst_1 : short fst], short y),
@pgame.cases_on
(λ (fst : pgame),
Π (snd : Σ' (y : pgame) [_inst_1 : short fst], short y),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd) ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd))],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd))) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd) <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd))],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
fst
snd))))
fst
(λ (fst_α fst_β : Type) (fst_a : fst_α → pgame) (fst_a_1 : fst_β → pgame)
(snd : Σ' (y : pgame) [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)], short y),
@psigma.cases_on pgame
(λ (y : pgame), Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)], short y)
(λ
(snd :
Σ' (y : pgame) [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)], short y),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd) ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd))],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd))) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd) <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd))],
short y)
(@psigma.snd pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
snd))))
snd
(λ (snd_fst : pgame)
(snd_snd : Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)], short snd_fst),
@pgame.cases_on
(λ (snd_fst : pgame),
Π
(snd_snd :
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)], short snd_fst),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r (Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)) ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)))],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)))) ×
decidable
(@psigma.fst pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)) <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)))],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
snd_fst
snd_snd)))))
snd_fst
(λ (snd_fst_α snd_fst_β : Type) (snd_fst_a : snd_fst_α → pgame)
(snd_fst_a_1 : snd_fst_β → pgame)
(snd_snd :
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short (mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)),
@psigma.cases_on (short (mk fst_α fst_β fst_a fst_a_1))
(λ [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short (mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
(λ
(snd_snd :
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short (mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)),
(Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r
(Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ' [_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
snd_snd)) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
snd_snd)) ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
snd_snd)))],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
snd_snd)))) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
snd_snd)) <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
snd_snd)))],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
snd_snd)))))
snd_snd
(λ (snd_snd_fst : short (mk fst_α fst_β fst_a fst_a_1))
(snd_snd_snd : short (mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)),
id_rhs
((Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r
(Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(@psigma.mk (short (mk fst_α fst_β fst_a fst_a_1))
(λ
[_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
snd_snd_fst
snd_snd_snd))) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y))) →
decidable
(mk fst_α fst_β fst_a fst_a_1 ≤
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1) ×
decidable
(mk fst_α fst_β fst_a fst_a_1 <
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
(λ
(_F :
Π (_y : Σ' (x y : pgame) [_inst_1 : short x], short y),
@has_well_founded.r
(Σ' (x y : pgame) [_inst_1 : short x], short y)
(@psigma.has_well_founded pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
pgame.has_well_founded
(λ (a : pgame),
@psigma.has_well_founded pgame
(λ (y : pgame), Σ' [_inst_1 : short a], short y)
pgame.has_well_founded
(λ (a_1 : pgame),
@psigma.has_well_founded (short a)
(λ [_inst_1 : short a], short a_1)
(@has_well_founded_of_has_sizeof (short a)
(short.has_sizeof_inst a))
(λ (a : short a),
@has_well_founded_of_has_sizeof (short a_1)
(short.has_sizeof_inst a_1)))))
_y
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short (mk fst_α fst_β fst_a fst_a_1)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(@psigma.mk (short (mk fst_α fst_β fst_a fst_a_1))
(λ
[_inst_1 : short (mk fst_α fst_β fst_a fst_a_1)],
short
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
snd_snd_fst
snd_snd_snd))) →
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y ≤
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y)) ×
decidable
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y <
@psigma.fst pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(@psigma.fst pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
_y)],
short y)
(@psigma.snd pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x], short y)
_y))),
(@eq.mpr
(decidable
(mk fst_α fst_β fst_a fst_a_1 ≤
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
(decidable
((∀ (i : fst_α),
fst_a i <
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1) ∧
∀ (j : snd_fst_β),
mk fst_α fst_β fst_a fst_a_1 < snd_fst_a_1 j))
_
(@and.decidable
(∀ (i : fst_α),
fst_a i <
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(∀ (j : snd_fst_β),
mk fst_α fst_β fst_a fst_a_1 < snd_fst_a_1 j)
(@fintype.decidable_forall_fintype fst_α
(@pgame.fintype_left fst_α fst_β fst_a fst_a_1
snd_snd_fst)
(λ (a : fst_α),
fst_a a <
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(@id
(@decidable_pred fst_α
(λ (a : fst_α),
fst_a a <
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(λ (i : fst_α),
@prod.snd
(decidable
(fst_a i ≤
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(decidable
(fst_a i <
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(_F
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(fst_a i)
(@psigma.mk pgame
(λ (y : pgame),
Σ' [_inst_1 : short (fst_a i)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
(@psigma.mk (short (fst_a i))
(λ [_inst_1 : short (fst_a i)],
short
(mk snd_fst_α snd_fst_β
snd_fst_a
snd_fst_a_1))
(@pgame.move_left_short' fst_α
fst_β
fst_a
fst_a_1
snd_snd_fst
i)
snd_snd_snd)))
_))))
(@fintype.decidable_forall_fintype snd_fst_β
(@pgame.fintype_right snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1
snd_snd_snd)
(λ (a : snd_fst_β),
mk fst_α fst_β fst_a fst_a_1 < snd_fst_a_1 a)
(@id
(@decidable_pred snd_fst_β
(λ (a : snd_fst_β),
mk fst_α fst_β fst_a fst_a_1 <
snd_fst_a_1 a))
(λ (i : snd_fst_β),
@prod.snd
(decidable
(mk fst_α fst_β fst_a fst_a_1 ≤
snd_fst_a_1 i))
(decidable
(mk fst_α fst_β fst_a fst_a_1 <
snd_fst_a_1 i))
(_F
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short y)
(snd_fst_a_1 i)
(@psigma.mk
(short
(mk fst_α fst_β fst_a fst_a_1))
(λ
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short (snd_fst_a_1 i))
snd_snd_fst
(@pgame.move_right_short' snd_fst_α
snd_fst_β
snd_fst_a
snd_fst_a_1
snd_snd_snd
i))))
_))))),
@eq.mpr
(decidable
(mk fst_α fst_β fst_a fst_a_1 <
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
(decidable
((∃ (i : snd_fst_α),
mk fst_α fst_β fst_a fst_a_1 ≤ snd_fst_a i) ∨
∃ (j : fst_β),
fst_a_1 j ≤
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1))
_
(@or.decidable
(∃ (i : snd_fst_α),
mk fst_α fst_β fst_a fst_a_1 ≤ snd_fst_a i)
(∃ (j : fst_β),
fst_a_1 j ≤
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(@fintype.decidable_exists_fintype snd_fst_α
(@pgame.fintype_left snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1
snd_snd_snd)
(λ (a : snd_fst_α),
mk fst_α fst_β fst_a fst_a_1 ≤ snd_fst_a a)
(@id
(@decidable_pred snd_fst_α
(λ (a : snd_fst_α),
mk fst_α fst_β fst_a fst_a_1 ≤
snd_fst_a a))
(λ (i : snd_fst_α),
@prod.fst
(decidable
(mk fst_α fst_β fst_a fst_a_1 ≤
snd_fst_a i))
(decidable
(mk fst_α fst_β fst_a fst_a_1 <
snd_fst_a i))
(_F
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(mk fst_α fst_β fst_a fst_a_1)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short y)
(snd_fst_a i)
(@psigma.mk
(short
(mk fst_α fst_β fst_a fst_a_1))
(λ
[_inst_1 :
short
(mk fst_α fst_β fst_a
fst_a_1)],
short (snd_fst_a i))
snd_snd_fst
(@pgame.move_left_short' snd_fst_α
snd_fst_β
snd_fst_a
snd_fst_a_1
snd_snd_snd
i))))
_))))
(@fintype.decidable_exists_fintype fst_β
(@pgame.fintype_right fst_α fst_β fst_a fst_a_1
snd_snd_fst)
(λ (a : fst_β),
fst_a_1 a ≤
mk snd_fst_α snd_fst_β snd_fst_a snd_fst_a_1)
(@id
(@decidable_pred fst_β
(λ (a : fst_β),
fst_a_1 a ≤
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(λ (i : fst_β),
@prod.fst
(decidable
(fst_a_1 i ≤
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(decidable
(fst_a_1 i <
mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1))
(_F
(@psigma.mk pgame
(λ (x : pgame),
Σ' (y : pgame) [_inst_1 : short x],
short y)
(fst_a_1 i)
(@psigma.mk pgame
(λ (y : pgame),
Σ' [_inst_1 : short (fst_a_1 i)],
short y)
(mk snd_fst_α snd_fst_β snd_fst_a
snd_fst_a_1)
(@psigma.mk (short (fst_a_1 i))
(λ [_inst_1 : short (fst_a_1 i)],
short
(mk snd_fst_α snd_fst_β
snd_fst_a
snd_fst_a_1))
(@pgame.move_right_short' fst_α
fst_β
fst_a
fst_a_1
snd_snd_fst
i)
snd_snd_snd)))
_)))))))))
snd_snd))
snd))
x₁
ih)
y
_)
(@psigma.mk pgame (λ (x : pgame), Σ' (y : pgame) [_inst_1 : short x], short y)
((λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y _x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i)
(@psigma.mk pgame
(λ (y : pgame),
Σ'
[_inst_1 :
short
((λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded
_y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i)],
short y)
(mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame))
(@psigma.mk
(short
((λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i))
(λ
[_inst_1 :
short
((λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
i)], short (mk punit pempty (λ (_x : punit), 0) (@pempty.elim pgame)))
(@pgame.move_left_short'
(left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]))
(λ
(m :
left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_left
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
(λ
(m :
right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
have this :
@finset.card (ℤ × ℤ)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m) <
@finset.card (ℤ × ℤ)
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)]), from
_,
(λ (y : finset (ℤ × ℤ))
(a :
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])),
@acc.rec (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
(λ (_x : finset (ℤ × ℤ)), (λ (_x : finset (ℤ × ℤ)), pgame) _x)
(λ (x₁ : finset (ℤ × ℤ))
(ac₁ :
∀ (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
@acc (finset (ℤ × ℤ))
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y)
(ih :
Π (y : finset (ℤ × ℤ)),
(λ (y x : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded y x)
y
x₁ →
(λ (_x : finset (ℤ × ℤ)), pgame) y),
(λ (_x : finset (ℤ × ℤ)),
id_rhs
((Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame) →
pgame)
(λ
(_F :
Π (_y : finset (ℤ × ℤ)),
@has_well_founded.r (finset (ℤ × ℤ)) finset.has_well_founded _y
_x →
pgame),
mk (left _x) (right _x)
(λ (m : left _x),
have this :
@finset.card (ℤ × ℤ) (move_left _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_left _x m) _)
(λ (m : right _x),
have this :
@finset.card (ℤ × ℤ) (move_right _x m) <
@finset.card (ℤ × ℤ) _x, from
_,
_F (move_right _x m) _)))
x₁
ih)
y
_)
(move_right
(@list.to_finset (ℤ × ℤ)
(λ (a b : ℤ × ℤ),
@prod.decidable_eq ℤ ℤ (λ (a b : ℤ), int.decidable_eq a b)
(λ (a b : ℤ), int.decidable_eq a b)
a
b)
[(0, 2), (0, 1), (0, 0), (1, 0)])
m)
_)
domineering.L.pgame.short
i)
pgame.short_1)))
_))))
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment