Split (1)

train · 193k rows

fact stringlengths 6 3.84k	type stringclasses 11 values	library stringclasses 32 values	imports listlengths 1 14	filename stringlengths 20 95	symbolic_name stringlengths 1 90	docstring stringlengths 7 20k ⌀
powHalf_leftMoves (n) : (powHalf n).LeftMoves = PUnit := by cases n <;> rfl	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_leftMoves	null
powHalf_zero_rightMoves : (powHalf 0).RightMoves = PEmpty := rfl	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_zero_rightMoves	null
powHalf_succ_rightMoves (n) : (powHalf (n + 1)).RightMoves = PUnit := rfl @[simp]	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_succ_rightMoves	null
powHalf_moveLeft (n i) : (powHalf n).moveLeft i = 0 := by cases n <;> cases i <;> rfl @[simp]	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_moveLeft	null
powHalf_succ_moveRight (n i) : (powHalf (n + 1)).moveRight i = powHalf n := rfl	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_succ_moveRight	null
uniquePowHalfLeftMoves (n) : Unique (powHalf n).LeftMoves := by cases n <;> exact PUnit.instUnique	instance	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	uniquePowHalfLeftMoves	null
isEmpty_powHalf_zero_rightMoves : IsEmpty (powHalf 0).RightMoves := inferInstanceAs (IsEmpty PEmpty)	instance	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	isEmpty_powHalf_zero_rightMoves	null
uniquePowHalfSuccRightMoves (n) : Unique (powHalf (n + 1)).RightMoves := PUnit.instUnique @[simp]	instance	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	uniquePowHalfSuccRightMoves	null
birthday_half : birthday (powHalf 1) = 2 := by rw [birthday_def]; simp	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	birthday_half	null
numeric_powHalf (n) : (powHalf n).Numeric := by induction n with \| zero => exact numeric_one \| succ n hn => constructor · simpa using hn.moveLeft_lt default · exact ⟨fun _ => numeric_zero, fun _ => hn⟩	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	numeric_powHalf	For all natural numbers `n`, the pre-games `powHalf n` are numeric.
powHalf_succ_lt_powHalf (n : ℕ) : powHalf (n + 1) < powHalf n := (numeric_powHalf (n + 1)).lt_moveRight default	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_succ_lt_powHalf	null
powHalf_succ_le_powHalf (n : ℕ) : powHalf (n + 1) ≤ powHalf n := (powHalf_succ_lt_powHalf n).le	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_succ_le_powHalf	null
powHalf_le_one (n : ℕ) : powHalf n ≤ 1 := by induction n with \| zero => exact le_rfl \| succ n hn => exact (powHalf_succ_le_powHalf n).trans hn	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_le_one	null
powHalf_succ_lt_one (n : ℕ) : powHalf (n + 1) < 1 := (powHalf_succ_lt_powHalf n).trans_le <\| powHalf_le_one n	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_succ_lt_one	null
powHalf_pos (n : ℕ) : 0 < powHalf n := by rw [← lf_iff_lt numeric_zero (numeric_powHalf n), zero_lf_le]; simp	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_pos	null
zero_le_powHalf (n : ℕ) : 0 ≤ powHalf n := (powHalf_pos n).le	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	zero_le_powHalf	null
add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by induction n using Nat.strong_induction_on with \| _ n hn constructor <;> rw [le_iff_forall_lf] <;> constructor · rintro (⟨⟨⟩⟩ \| ⟨⟨⟩⟩) <;> apply lf_of_lt · calc 0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _ _ < powHalf n := powHalf_succ_lt_powHalf n · calc powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _ _ < powHalf n := powHalf_succ_lt_powHalf n · rcases n with - \| n · rintro ⟨⟩ rintro ⟨⟩ apply lf_of_moveRight_le swap · exact Sum.inl default calc powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ := add_le_add_left (powHalf_succ_le_powHalf _) _ _ ≈ powHalf n := hn _ (Nat.lt_succ_self n) · simp only [powHalf_moveLeft, forall_const] apply lf_of_lt calc 0 ≈ 0 + 0 := Equiv.symm (add_zero_equiv 0) _ ≤ powHalf n.succ + 0 := add_le_add_right (zero_le_powHalf _) _ _ < powHalf n.succ + powHalf n.succ := add_lt_add_left (powHalf_pos _) _ · rintro (⟨⟨⟩⟩ \| ⟨⟨⟩⟩) <;> apply lf_of_lt · calc powHalf n ≈ powHalf n + 0 := Equiv.symm (add_zero_equiv _) _ < powHalf n + powHalf n.succ := add_lt_add_left (powHalf_pos _) _ · calc powHalf n ≈ 0 + powHalf n := Equiv.symm (zero_add_equiv _) _ < powHalf n.succ + powHalf n := add_lt_add_right (powHalf_pos _) _	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	add_powHalf_succ_self_eq_powHalf	null
half_add_half_equiv_one : powHalf 1 + powHalf 1 ≈ 1 := add_powHalf_succ_self_eq_powHalf 0	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	half_add_half_equiv_one	null
powHalf (n : ℕ) : Surreal := ⟦⟨PGame.powHalf n, PGame.numeric_powHalf n⟩⟧ @[simp]	def	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf	Powers of the surreal number `half`.
powHalf_zero : powHalf 0 = 1 := rfl @[simp]	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	powHalf_zero	null
double_powHalf_succ_eq_powHalf (n : ℕ) : 2 * powHalf (n + 1) = powHalf n := by rw [two_mul]; exact Quotient.sound (PGame.add_powHalf_succ_self_eq_powHalf n) @[simp]	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	double_powHalf_succ_eq_powHalf	null
nsmul_pow_two_powHalf (n : ℕ) : 2 ^ n * powHalf n = 1 := by induction n with \| zero => simp only [pow_zero, powHalf_zero, mul_one] \| succ n hn => rw [← hn, ← double_powHalf_succ_eq_powHalf n, ← mul_assoc (2 ^ n) 2 (powHalf (n + 1)), pow_succ', mul_comm 2 (2 ^ n)] @[simp]	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	nsmul_pow_two_powHalf	null
nsmul_pow_two_powHalf' (n k : ℕ) : 2 ^ n * powHalf (n + k) = powHalf k := by induction k with \| zero => simp only [add_zero, Surreal.nsmul_pow_two_powHalf, Surreal.powHalf_zero] \| succ k hk => rw [← double_powHalf_succ_eq_powHalf (n + k), ← double_powHalf_succ_eq_powHalf k, ← mul_assoc, mul_comm (2 ^ n) 2, mul_assoc] at hk rw [← zsmul_eq_zsmul_iff' two_ne_zero] simpa only [zsmul_eq_mul, Int.cast_ofNat]	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	nsmul_pow_two_powHalf'	null
zsmul_pow_two_powHalf (m : ℤ) (n k : ℕ) : (m * 2 ^ n) * powHalf (n + k) = m * powHalf k := by rw [mul_assoc] congr exact nsmul_pow_two_powHalf' n k	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	zsmul_pow_two_powHalf	null
dyadic_aux {m₁ m₂ : ℤ} {y₁ y₂ : ℕ} (h₂ : m₁ * 2 ^ y₁ = m₂ * 2 ^ y₂) : m₁ * powHalf y₂ = m₂ * powHalf y₁ := by revert m₁ m₂ wlog h : y₁ ≤ y₂ · intro m₁ m₂ aux; exact (this (le_of_not_ge h) aux.symm).symm intro m₁ m₂ h₂ obtain ⟨c, rfl⟩ := le_iff_exists_add.mp h rw [add_comm, pow_add, ← mul_assoc, mul_eq_mul_right_iff] at h₂ rcases h₂ with h₂ \| h₂ · rw [h₂, add_comm] simp_rw [Int.cast_mul, Int.cast_pow, Int.cast_ofNat, zsmul_pow_two_powHalf m₂ c y₁] · have := Nat.one_le_pow y₁ 2 Nat.succ_pos' norm_cast at h₂; cutsat	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	dyadic_aux	null
noncomputable dyadicMap : Localization.Away (2 : ℤ) →+ Surreal where toFun x := (Localization.liftOn x fun x y => x * powHalf (Submonoid.log y)) <\| by intro m₁ m₂ n₁ n₂ h₁ obtain ⟨⟨n₃, y₃, hn₃⟩, h₂⟩ := Localization.r_iff_exists.mp h₁ simp only [mul_eq_mul_left_iff] at h₂ cases h₂ · obtain ⟨a₁, ha₁⟩ := n₁.prop obtain ⟨a₂, ha₂⟩ := n₂.prop simp only at ha₁ ha₂ ⊢ have hn₁ : n₁ = Submonoid.pow 2 a₁ := Subtype.ext ha₁.symm have hn₂ : n₂ = Submonoid.pow 2 a₂ := Subtype.ext ha₂.symm have h₂ : 1 < (2 : ℤ).natAbs := one_lt_two rw [hn₁, hn₂, Submonoid.log_pow_int_eq_self h₂, Submonoid.log_pow_int_eq_self h₂] apply dyadic_aux rwa [ha₁, ha₂, mul_comm, mul_comm m₂] · have : (1 : ℤ) ≤ 2 ^ y₃ := mod_cast Nat.one_le_pow y₃ 2 Nat.succ_pos' linarith map_zero' := by simp_rw [Localization.liftOn_zero _ _, Int.cast_zero, zero_mul] map_add' x y := Localization.induction_on₂ x y <\| by rintro ⟨a, ⟨b, ⟨b', rfl⟩⟩⟩ ⟨c, ⟨d, ⟨d', rfl⟩⟩⟩ have h₂ : 1 < (2 : ℤ).natAbs := one_lt_two have hpow₂ := Submonoid.log_pow_int_eq_self h₂ simp_rw [Submonoid.pow_apply] at hpow₂ simp_rw [Localization.add_mk, Localization.liftOn_mk, Submonoid.log_mul (Int.pow_right_injective h₂), hpow₂] simp only [Int.cast_add, Int.cast_mul, Int.cast_pow, Int.cast_ofNat] calc (2 ^ b' * c + 2 ^ d' * a) * powHalf (b' + d') = (c * 2 ^ b') * powHalf (b' + d') + (a * 2 ^ d') * powHalf (d' + b') := by simp only [right_distrib, mul_comm, add_comm] _ = c * powHalf d' + a * powHalf b' := by simp only [zsmul_pow_two_powHalf] _ = a * powHalf b' + c * powHalf d' := add_comm _ _ @[simp]	def	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	dyadicMap	The additive monoid morphism `dyadicMap` sends ⟦⟨m, 2^n⟩⟧ to m • half ^ n.
dyadicMap_apply (m : ℤ) (p : Submonoid.powers (2 : ℤ)) : dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m p) = m * powHalf (Submonoid.log p) := by rw [← Localization.mk_eq_mk']; rfl	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	dyadicMap_apply	null
dyadicMap_apply_pow (m : ℤ) (n : ℕ) : dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m (Submonoid.pow 2 n)) = m • powHalf n := by rw [dyadicMap_apply, @Submonoid.log_pow_int_eq_self 2 one_lt_two] simp only [zsmul_eq_mul] @[simp]	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	dyadicMap_apply_pow	null
dyadicMap_apply_pow' (m : ℤ) (n : ℕ) : m * Surreal.powHalf (Submonoid.log (Submonoid.pow (2 : ℤ) n)) = m * powHalf n := by rw [@Submonoid.log_pow_int_eq_self 2 one_lt_two]	theorem	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	dyadicMap_apply_pow'	null
dyadic : Set Surreal := Set.range dyadicMap	def	SetTheory	[ "Mathlib.Algebra.Algebra.Defs", "Mathlib.Algebra.Order.Group.Basic", "Mathlib.Algebra.Ring.Regular", "Mathlib.GroupTheory.MonoidLocalization.Away", "Mathlib.RingTheory.Localization.Defs", "Mathlib.SetTheory.Game.Birthday", "Mathlib.SetTheory.Surreal.Multiplication", "Mathlib.Tactic.Linarith", "Mathl...	Mathlib/SetTheory/Surreal/Dyadic.lean	dyadic	We define dyadic surreals as the range of the map `dyadicMap`.
P1 (x₁ x₂ x₃ y₁ y₂ y₃ : PGame) := ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧ - ⟦x₁ * y₂⟧ < ⟦x₃ * y₁⟧ + ⟦x₂ * y₃⟧ - (⟦x₃ * y₃⟧ : Game)	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P1	The nontrivial part of P1 in [SchleicherStoll] says that the left options of `x * y` are less than the right options, and this is the general form of these statements.
P2 (x₁ x₂ y : PGame) := x₁ ≈ x₂ → ⟦x₁ * y⟧ = (⟦x₂ * y⟧ : Game)	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P2	The proposition P2, without numericity assumptions.
P3 (x₁ x₂ y₁ y₂ : PGame) := ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + (⟦x₂ * y₂⟧ : Game)	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P3	The proposition P3, without the `x₁ < x₂` and `y₁ < y₂` assumptions.
P4 (x₁ x₂ y : PGame) := x₁ < x₂ → (∀ i, P3 x₁ x₂ (y.moveLeft i) y) ∧ ∀ j, P3 x₁ x₂ ((-y).moveLeft j) (-y)	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P4	The proposition P4, without numericity assumptions. In the references, the second part of the conjunction is stated as `∀ j, P3 x₁ x₂ y (y.moveRight j)`, which is equivalent to our statement by `P3_comm` and `P3_neg`. We choose to state everything in terms of left options for uniform treatment.
P24 (x₁ x₂ y : PGame) : Prop := P2 x₁ x₂ y ∧ P4 x₁ x₂ y variable {x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame.{u}} /-! #### Symmetry properties of P1, P2, P3, and P4 -/	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P24	The conjunction of P2 and P4.
P3_comm : P3 x₁ x₂ y₁ y₂ ↔ P3 y₁ y₂ x₁ x₂ := by rw [P3, P3, add_comm] congr! 2 <;> rw [quot_mul_comm]	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P3_comm	null
P3.trans (h₁ : P3 x₁ x₂ y₁ y₂) (h₂ : P3 x₂ x₃ y₁ y₂) : P3 x₁ x₃ y₁ y₂ := by rw [P3] at h₁ h₂ rw [P3, ← add_lt_add_iff_left (⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧)] convert add_lt_add h₁ h₂ using 1 <;> abel	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P3.trans	null
P3_neg : P3 x₁ x₂ y₁ y₂ ↔ P3 (-x₂) (-x₁) y₁ y₂ := by simp_rw [P3, quot_neg_mul] rw [← _root_.neg_lt_neg_iff] abel_nf	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P3_neg	null
P2_neg_left : P2 x₁ x₂ y ↔ P2 (-x₂) (-x₁) y := by rw [P2, P2] constructor · rw [quot_neg_mul, quot_neg_mul, eq_comm, neg_inj, neg_equiv_neg_iff, PGame.equiv_comm] exact (· ·) · rw [PGame.equiv_comm, neg_equiv_neg_iff, quot_neg_mul, quot_neg_mul, neg_inj, eq_comm] exact (· ·)	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P2_neg_left	null
P2_neg_right : P2 x₁ x₂ y ↔ P2 x₁ x₂ (-y) := by rw [P2, P2, quot_mul_neg, quot_mul_neg, neg_inj]	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P2_neg_right	null
P4_neg_left : P4 x₁ x₂ y ↔ P4 (-x₂) (-x₁) y := by simp_rw [P4, PGame.neg_lt_neg_iff, moveLeft_neg, ← P3_neg]	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P4_neg_left	null
P4_neg_right : P4 x₁ x₂ y ↔ P4 x₁ x₂ (-y) := by rw [P4, P4, neg_neg, and_comm]	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P4_neg_right	null
P24_neg_left : P24 x₁ x₂ y ↔ P24 (-x₂) (-x₁) y := by rw [P24, P24, P2_neg_left, P4_neg_left]	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P24_neg_left	null
P24_neg_right : P24 x₁ x₂ y ↔ P24 x₁ x₂ (-y) := by rw [P24, P24, P2_neg_right, P4_neg_right] /-! #### Explicit calculations necessary for the main proof -/	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P24_neg_right	null
mulOption_lt_iff_P1 {i j k l} : (⟦mulOption x y i k⟧ : Game) < -⟦mulOption x (-y) j l⟧ ↔ P1 (x.moveLeft i) x (x.moveLeft j) y (y.moveLeft k) (-(-y).moveLeft l) := by dsimp only [P1, mulOption, quot_sub, quot_add] simp_rw [neg_sub', neg_add, quot_mul_neg, neg_neg]	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	mulOption_lt_iff_P1	null
mulOption_lt_mul_iff_P3 {i j} : ⟦mulOption x y i j⟧ < (⟦x * y⟧ : Game) ↔ P3 (x.moveLeft i) x (y.moveLeft j) y := by dsimp only [mulOption, quot_sub, quot_add] exact sub_lt_iff_lt_add'	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	mulOption_lt_mul_iff_P3	null
P1_of_eq (he : x₁ ≈ x₃) (h₁ : P2 x₁ x₃ y₁) (h₃ : P2 x₁ x₃ y₃) (h3 : P3 x₁ x₂ y₂ y₃) : P1 x₁ x₂ x₃ y₁ y₂ y₃ := by rw [P1, ← h₁ he, ← h₃ he, sub_lt_sub_iff] convert add_lt_add_left h3 ⟦x₁ * y₁⟧ using 1 <;> abel	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P1_of_eq	null
P1_of_lt (h₁ : P3 x₃ x₂ y₂ y₃) (h₂ : P3 x₁ x₃ y₂ y₁) : P1 x₁ x₂ x₃ y₁ y₂ y₃ := by rw [P1, sub_lt_sub_iff, ← add_lt_add_iff_left ⟦x₃ * y₂⟧] convert add_lt_add h₁ h₂ using 1 <;> abel	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P1_of_lt	null
Args : Type (u + 1) \| P1 (x y : PGame.{u}) : Args \| P24 (x₁ x₂ y : PGame.{u}) : Args	inductive	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Args	The type of lists of arguments for P1, P2, and P4.
Args.toMultiset : Args → Multiset PGame \| (Args.P1 x y) => {x, y} \| (Args.P24 x₁ x₂ y) => {x₁, x₂, y}	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Args.toMultiset	The multiset associated to a list of arguments.
Args.Numeric (a : Args) := ∀ x ∈ a.toMultiset, SetTheory.PGame.Numeric x	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Args.Numeric	A list of arguments is numeric if all the arguments are.
Args.numeric_P1 {x y} : (Args.P1 x y).Numeric ↔ x.Numeric ∧ y.Numeric := by simp [Args.Numeric, Args.toMultiset]	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Args.numeric_P1	null
Args.numeric_P24 {x₁ x₂ y} : (Args.P24 x₁ x₂ y).Numeric ↔ x₁.Numeric ∧ x₂.Numeric ∧ y.Numeric := by simp [Args.Numeric, Args.toMultiset] open Relation	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Args.numeric_P24	null
ArgsRel := InvImage (TransGen <\| CutExpand IsOption) Args.toMultiset	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ArgsRel	The relation specifying when a list of (pregame) arguments is considered simpler than another: `ArgsRel a₁ a₂` is true if `a₁`, considered as a multiset, can be obtained from `a₂` by repeatedly removing a pregame from `a₂` and adding back one or two options of the pregame.
argsRel_wf : WellFounded ArgsRel := InvImage.wf _ wf_isOption.cutExpand.transGen	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	argsRel_wf	`ArgsRel` is well-founded.
P124 : Args → Prop \| (Args.P1 x y) => Numeric (x * y) \| (Args.P24 x₁ x₂ y) => P24 x₁ x₂ y	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P124	The statement that we will show by induction using the well-founded relation `ArgsRel`.
ArgsRel.numeric_closed {a' a} : ArgsRel a' a → a.Numeric → a'.Numeric := TransGen.closed' <\| @cutExpand_closed _ IsOption ⟨wf_isOption.isIrrefl.1⟩ _ Numeric.isOption	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ArgsRel.numeric_closed	The property that all arguments are numeric is leftward-closed under `ArgsRel`.
IH1 (x y : PGame) : Prop := ∀ ⦃x₁ x₂ y'⦄, IsOption x₁ x → IsOption x₂ x → (y' = y ∨ IsOption y' y) → P24 x₁ x₂ y' /-! #### Symmetry properties of `IH1` -/	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	IH1	A specialized induction hypothesis used to prove P1.
ih1_neg_left : IH1 x y → IH1 (-x) y := fun h x₁ x₂ y' h₁ h₂ hy ↦ by rw [isOption_neg] at h₁ h₂ exact P24_neg_left.2 (h h₂ h₁ hy)	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih1_neg_left	null
ih1_neg_right : IH1 x y → IH1 x (-y) := fun h x₁ x₂ y' ↦ by rw [← neg_eq_iff_eq_neg, isOption_neg, P24_neg_right] apply h /-! #### Specialize `ih` to obtain specialized induction hypotheses for P1 -/	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih1_neg_right	null
numeric_option_mul (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (h : IsOption x' x) : (x' * y).Numeric := ih (Args.P1 x' y) (TransGen.single <\| cutExpand_pair_left h)	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	numeric_option_mul	null
numeric_mul_option (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (h : IsOption y' y) : (x * y').Numeric := ih (Args.P1 x y') (TransGen.single <\| cutExpand_pair_right h)	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	numeric_mul_option	null
numeric_option_mul_option (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (hx : IsOption x' x) (hy : IsOption y' y) : (x' * y').Numeric := ih (Args.P1 x' y') ((TransGen.single <\| cutExpand_pair_right hy).tail <\| cutExpand_pair_left hx)	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	numeric_option_mul_option	null
ih1 (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) : IH1 x y := by rintro x₁ x₂ y' h₁ h₂ (rfl \| hy) <;> apply ih (Args.P24 _ _ _) on_goal 2 => refine TransGen.tail ?_ (cutExpand_pair_right hy) all_goals exact TransGen.single (cutExpand_double_left h₁ h₂)	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih1	null
ih1_swap (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) : IH1 y x := ih1 <\| by simp_rw [ArgsRel, InvImage, Args.toMultiset, Multiset.pair_comm] at ih ⊢ exact ih	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih1_swap	null
P3_of_ih (hy : Numeric y) (ihyx : IH1 y x) (i k l) : P3 (x.moveLeft i) x (y.moveLeft k) (-(-y).moveLeft l) := P3_comm.2 <\| ((ihyx (IsOption.moveLeft k) (isOption_neg.1 <\| .moveLeft l) <\| Or.inl rfl).2 (by rw [moveLeft_neg, neg_neg]; apply hy.left_lt_right)).1 i	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P3_of_ih	null
P24_of_ih (ihxy : IH1 x y) (i j) : P24 (x.moveLeft i) (x.moveLeft j) y := ihxy (IsOption.moveLeft i) (IsOption.moveLeft j) (Or.inl rfl)	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P24_of_ih	null
mulOption_lt_of_lt (hy : y.Numeric) (ihxy : IH1 x y) (ihyx : IH1 y x) (i j k l) (h : x.moveLeft i < x.moveLeft j) : (⟦mulOption x y i k⟧ : Game) < -⟦mulOption x (-y) j l⟧ := mulOption_lt_iff_P1.2 <\| P1_of_lt (P3_of_ih hy ihyx j k l) <\| ((P24_of_ih ihxy i j).2 h).1 k	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	mulOption_lt_of_lt	null
mulOption_lt (hx : x.Numeric) (hy : y.Numeric) (ihxy : IH1 x y) (ihyx : IH1 y x) (i j k l) : (⟦mulOption x y i k⟧ : Game) < -⟦mulOption x (-y) j l⟧ := by obtain (h \| h \| h) := lt_or_equiv_or_gt (hx.moveLeft i) (hx.moveLeft j) · exact mulOption_lt_of_lt hy ihxy ihyx i j k l h · have ml := @IsOption.moveLeft exact mulOption_lt_iff_P1.2 (P1_of_eq h (P24_of_ih ihxy i j).1 (ihxy (ml i) (ml j) <\| Or.inr <\| isOption_neg.1 <\| ml l).1 <\| P3_of_ih hy ihyx i k l) · rw [mulOption_neg_neg, lt_neg] exact mulOption_lt_of_lt hy.neg (ih1_neg_right ihxy) (ih1_neg_left ihyx) j i l _ h	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	mulOption_lt	null
P1_of_ih (ih : ∀ a, ArgsRel a (Args.P1 x y) → P124 a) (hx : x.Numeric) (hy : y.Numeric) : (x * y).Numeric := by have ihxy := ih1 ih have ihyx := ih1_swap ih have ihxyn := ih1_neg_left (ih1_neg_right ihxy) have ihyxn := ih1_neg_left (ih1_neg_right ihyx) refine numeric_def.mpr ⟨?_, ?_, ?_⟩ · simp_rw [lt_iff_game_lt] intro i rw [rightMoves_mul_iff] constructor <;> (intro j l; revert i; rw [leftMoves_mul_iff (_ > ·)]; constructor <;> intro i k) · apply mulOption_lt hx hy ihxy ihyx · simp_rw [← mulOption_symm (-y), mulOption_neg_neg x] apply mulOption_lt hy.neg hx.neg ihyxn ihxyn · simp only [← mulOption_symm y] apply mulOption_lt hy hx ihyx ihxy · rw [mulOption_neg_neg y] apply mulOption_lt hx.neg hy.neg ihxyn ihyxn all_goals cases x; cases y rintro (⟨i, j⟩ \| ⟨i, j⟩) <;> refine ((numeric_option_mul ih ?_).add <\| numeric_mul_option ih ?_).sub (numeric_option_mul_option ih ?_ ?_) <;> solve_by_elim [IsOption.mk_left, IsOption.mk_right]	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P1_of_ih	P1 follows from the induction hypothesis.
IH24 (x₁ x₂ y : PGame) : Prop := ∀ ⦃z⦄, (IsOption z x₁ → P24 z x₂ y) ∧ (IsOption z x₂ → P24 x₁ z y) ∧ (IsOption z y → P24 x₁ x₂ z)	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	IH24	A specialized induction hypothesis used to prove P2 and P4.
IH4 (x₁ x₂ y : PGame) : Prop := ∀ ⦃z w⦄, IsOption w y → (IsOption z x₁ → P2 z x₂ w) ∧ (IsOption z x₂ → P2 x₁ z w) /-! #### Specialize `ih'` to obtain specialized induction hypotheses for P2 and P4 -/	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	IH4	A specialized induction hypothesis used to prove P4.
ih₁₂ (ih' : ∀ a, ArgsRel a (Args.P24 x₁ x₂ y) → P124 a) : IH24 x₁ x₂ y := by rw [IH24] refine fun z ↦ ⟨?_, ?_, ?_⟩ <;> refine fun h ↦ ih' (Args.P24 _ _ _) (TransGen.single ?_) · exact (cutExpand_add_right {y}).2 (cutExpand_pair_left h) · exact (cutExpand_add_left {x₁}).2 (cutExpand_pair_left h) · exact (cutExpand_add_left {x₁}).2 (cutExpand_pair_right h)	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih₁₂	null
ih₂₁ (ih' : ∀ a, ArgsRel a (Args.P24 x₁ x₂ y) → P124 a) : IH24 x₂ x₁ y := ih₁₂ <\| by simp_rw [ArgsRel, InvImage, Args.toMultiset, Multiset.pair_comm] at ih' ⊢ suffices {x₁, y, x₂} = {x₂, y, x₁} by rwa [← this] dsimp only [Multiset.insert_eq_cons, ← Multiset.singleton_add] at ih' ⊢ abel	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih₂₁	null
ih4 (ih' : ∀ a, ArgsRel a (Args.P24 x₁ x₂ y) → P124 a) : IH4 x₁ x₂ y := by refine fun z w h ↦ ⟨?_, ?_⟩ all_goals intro h' apply (ih' (Args.P24 _ _ _) <\| (TransGen.single _).tail <\| (cutExpand_add_left {x₁}).2 <\| cutExpand_pair_right h).1 try exact (cutExpand_add_right {w}).2 <\| cutExpand_pair_left h' try exact (cutExpand_add_right {w}).2 <\| cutExpand_pair_right h'	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih4	null
numeric_of_ih (ih' : ∀ a, ArgsRel a (Args.P24 x₁ x₂ y) → P124 a) : (x₁ * y).Numeric ∧ (x₂ * y).Numeric := by constructor <;> refine ih' (Args.P1 _ _) (TransGen.single ?_) · exact (cutExpand_add_right {y}).2 <\| (cutExpand_add_left {x₁}).2 cutExpand_zero · exact (cutExpand_add_right {x₂, y}).2 cutExpand_zero	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	numeric_of_ih	null
ih24_neg : IH24 x₁ x₂ y → IH24 (-x₂) (-x₁) y ∧ IH24 x₁ x₂ (-y) := by simp_rw [IH24, ← P24_neg_right, isOption_neg] refine fun h ↦ ⟨fun z ↦ ⟨?_, ?_, ?_⟩, fun z ↦ ⟨(@h z).1, (@h z).2.1, P24_neg_right.2 ∘ (@h <\| -z).2.2⟩⟩ all_goals rw [P24_neg_left] simp only [neg_neg] first \| exact (@h <\| -z).2.1 \| exact (@h <\| -z).1 \| exact (@h z).2.2	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih24_neg	Symmetry properties of `IH24`.
ih4_neg : IH4 x₁ x₂ y → IH4 (-x₂) (-x₁) y ∧ IH4 x₁ x₂ (-y) := by simp_rw [IH4, isOption_neg] refine fun h ↦ ⟨fun z w h' ↦ ?_, fun z w h' ↦ ?_⟩ · convert (h h').symm using 2 <;> rw [P2_neg_left, neg_neg] · convert h h' using 2 <;> rw [P2_neg_right]	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih4_neg	Symmetry properties of `IH4`.
mulOption_lt_mul_of_equiv (hn : x₁.Numeric) (h : IH24 x₁ x₂ y) (he : x₁ ≈ x₂) (i j) : ⟦mulOption x₁ y i j⟧ < (⟦x₂ * y⟧ : Game) := by convert sub_lt_iff_lt_add'.2 ((((@h _).1 <\| IsOption.moveLeft i).2 _).1 j) using 1 · rw [← ((@h _).2.2 <\| IsOption.moveLeft j).1 he] rfl · rw [← lt_congr_right he] apply hn.moveLeft_lt	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	mulOption_lt_mul_of_equiv	null
mul_right_le_of_equiv (h₁ : x₁.Numeric) (h₂ : x₂.Numeric) (h₁₂ : IH24 x₁ x₂ y) (h₂₁ : IH24 x₂ x₁ y) (he : x₁ ≈ x₂) : x₁ * y ≤ x₂ * y := by have he' := neg_equiv_neg_iff.2 he apply PGame.le_of_forall_lt <;> simp_rw [lt_iff_game_lt] · rw [leftMoves_mul_iff (_ > ·)] refine ⟨mulOption_lt_mul_of_equiv h₁ h₁₂ he, ?_⟩ rw [← quot_neg_mul_neg] exact mulOption_lt_mul_of_equiv h₁.neg (ih24_neg <\| (ih24_neg h₂₁).1).2 he' · rw [rightMoves_mul_iff] constructor <;> intros <;> rw [lt_neg] · rw [← quot_mul_neg] apply mulOption_lt_mul_of_equiv h₂ (ih24_neg h₂₁).2 (symm he) · rw [← quot_neg_mul] apply mulOption_lt_mul_of_equiv h₂.neg (ih24_neg h₁₂).1 (symm he')	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	mul_right_le_of_equiv	P2 follows from specialized induction hypotheses (one half of the equality).
MulOptionsLTMul (x y : PGame) : Prop := ∀ ⦃i j⦄, ⟦mulOption x y i j⟧ < (⟦x * y⟧ : Game)	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	MulOptionsLTMul	The statement that all left options of `x * y` of the first kind are less than itself.
mulOptionsLTMul_of_numeric (hn : (x * y).Numeric) : (MulOptionsLTMul x y ∧ MulOptionsLTMul (-x) (-y)) ∧ (MulOptionsLTMul x (-y) ∧ MulOptionsLTMul (-x) y) := by constructor · have h := hn.moveLeft_lt simp_rw [lt_iff_game_lt] at h convert (leftMoves_mul_iff <\| GT.gt _).1 h rw [← quot_neg_mul_neg] rfl · have h := hn.lt_moveRight simp_rw [lt_iff_game_lt, rightMoves_mul_iff] at h refine h.imp ?_ ?_ <;> refine forall₂_imp fun a b ↦ ?_ all_goals rw [lt_neg] first \| rw [quot_mul_neg] \| rw [quot_neg_mul] exact id	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	mulOptionsLTMul_of_numeric	That the left options of `x * y` are less than itself and the right options are greater, which is part of the condition that `x * y` is numeric, is equivalent to the conjunction of various `MulOptionsLTMul` statements for `x`, `y` and their negations. We only show the forward direction.
IH3 (x₁ x' x₂ y₁ y₂ : PGame) : Prop := P2 x₁ x' y₁ ∧ P2 x₁ x' y₂ ∧ P3 x' x₂ y₁ y₂ ∧ (x₁ < x' → P3 x₁ x' y₁ y₂)	def	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	IH3	A condition just enough to deduce P3, which will always be used with `x'` being a left option of `x₂`. When `y₁` is a left option of `y₂`, it can be deduced from induction hypotheses `IH24 x₁ x₂ y₂`, `IH4 x₁ x₂ y₂`, and `(x₂ * y₂).Numeric` (`ih3_of_ih`); when `y₁` is not necessarily an option of `y₂`, it follows from the induction hypothesis for P3 (with `x₂` replaced by a left option `x'`) after the `main` theorem (P124) is established, and is used to prove P3 in full (`P3_of_lt_of_lt`).
ih3_of_ih (h24 : IH24 x₁ x₂ y) (h4 : IH4 x₁ x₂ y) (hl : MulOptionsLTMul x₂ y) (i j) : IH3 x₁ (x₂.moveLeft i) x₂ (y.moveLeft j) y := have ml := @IsOption.moveLeft have h24 := (@h24 _).2.1 (ml i) ⟨(h4 <\| ml j).2 (ml i), h24.1, mulOption_lt_mul_iff_P3.1 (@hl i j), fun l ↦ (h24.2 l).1 _⟩	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	ih3_of_ih	null
P3_of_le_left {y₁ y₂} (i) (h : IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂) (hl : x₁ ≤ x₂.moveLeft i) : P3 x₁ x₂ y₁ y₂ := by obtain (hl \| he) := lt_or_equiv_of_le hl · exact (h.2.2.2 hl).trans h.2.2.1 · rw [P3, h.1 he, h.2.1 he] exact h.2.2.1	lemma	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P3_of_le_left	null
P3_of_lt {y₁ y₂} (h : ∀ i, IH3 x₁ (x₂.moveLeft i) x₂ y₁ y₂) (hs : ∀ i, IH3 (-x₂) ((-x₁).moveLeft i) (-x₁) y₁ y₂) (hl : x₁ < x₂) : P3 x₁ x₂ y₁ y₂ := by obtain (⟨i, hi⟩ \| ⟨i, hi⟩) := lf_iff_exists_le.1 (lf_of_lt hl) · exact P3_of_le_left i (h i) hi · apply P3_neg.2 <\| P3_of_le_left _ (hs (toLeftMovesNeg i)) _ simpa	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P3_of_lt	P3 follows from `IH3` (so P4 (with `y₁` a left option of `y₂`) follows from the induction hypothesis).
main (a : Args) : a.Numeric → P124 a := by apply argsRel_wf.induction a intro a ih ha replace ih : ∀ a', ArgsRel a' a → P124 a' := fun a' hr ↦ ih a' hr (hr.numeric_closed ha) cases a with /- P1 -/ \| P1 x y => rw [Args.numeric_P1] at ha exact P1_of_ih ih ha.1 ha.2 \| P24 x₁ x₂ y => have h₁₂ := ih₁₂ ih have h₂₁ := ih₂₁ ih have h4 := ih4 ih obtain ⟨h₁₂x, h₁₂y⟩ := ih24_neg h₁₂ obtain ⟨h4x, h4y⟩ := ih4_neg h4 refine ⟨fun he ↦ Quotient.sound ?_, fun hl ↦ ?_⟩ · /- P2 -/ rw [Args.numeric_P24] at ha exact ⟨mul_right_le_of_equiv ha.1 ha.2.1 h₁₂ h₂₁ he, mul_right_le_of_equiv ha.2.1 ha.1 h₂₁ h₁₂ (symm he)⟩ · /- P4 -/ obtain ⟨hn₁, hn₂⟩ := numeric_of_ih ih obtain ⟨⟨h₁, -⟩, h₂, -⟩ := mulOptionsLTMul_of_numeric hn₂ obtain ⟨⟨-, h₃⟩, -, h₄⟩ := mulOptionsLTMul_of_numeric hn₁ constructor <;> intro <;> refine P3_of_lt ?_ ?_ hl <;> intro <;> apply ih3_of_ih any_goals assumption exacts [(ih24_neg h₁₂y).1, (ih4_neg h4y).1]	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	main	The main chunk of Theorem 8 in [Conway2001] / Theorem 3.8 in [SchleicherStoll].
Numeric.mul (hx : x.Numeric) (hy : y.Numeric) : Numeric (x * y) := main _ <\| Args.numeric_P1.mpr ⟨hx, hy⟩	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Numeric.mul	null
P24 (hx₁ : x₁.Numeric) (hx₂ : x₂.Numeric) (hy : y.Numeric) : P24 x₁ x₂ y := main _ <\| Args.numeric_P24.mpr ⟨hx₁, hx₂, hy⟩	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P24	null
Equiv.mul_congr_left (hx₁ : x₁.Numeric) (hx₂ : x₂.Numeric) (hy : y.Numeric) (he : x₁ ≈ x₂) : x₁ * y ≈ x₂ * y := equiv_iff_game_eq.2 <\| (P24 hx₁ hx₂ hy).1 he	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Equiv.mul_congr_left	null
Equiv.mul_congr_right (hx : x.Numeric) (hy₁ : y₁.Numeric) (hy₂ : y₂.Numeric) (he : y₁ ≈ y₂) : x * y₁ ≈ x * y₂ := .trans (mul_comm_equiv _ _) <\| .trans (mul_congr_left hy₁ hy₂ hx he) (mul_comm_equiv _ _)	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Equiv.mul_congr_right	null
Equiv.mul_congr (hx₁ : x₁.Numeric) (hx₂ : x₂.Numeric) (hy₁ : y₁.Numeric) (hy₂ : y₂.Numeric) (hx : x₁ ≈ x₂) (hy : y₁ ≈ y₂) : x₁ * y₁ ≈ x₂ * y₂ := .trans (mul_congr_left hx₁ hx₂ hy₁ hx) (mul_congr_right hx₂ hy₁ hy₂ hy) open Prod.GameAdd	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Equiv.mul_congr	null
P3_of_lt_of_lt (hx₁ : x₁.Numeric) (hx₂ : x₂.Numeric) (hy₁ : y₁.Numeric) (hy₂ : y₂.Numeric) (hx : x₁ < x₂) (hy : y₁ < y₂) : P3 x₁ x₂ y₁ y₂ := by revert x₁ x₂ rw [← Prod.forall'] refine (wf_isOption.prod_gameAdd wf_isOption).fix ?_ rintro ⟨x₁, x₂⟩ ih hx₁ hx₂ hx refine P3_of_lt ?_ ?_ hx <;> intro i · have hi := hx₂.moveLeft i exact ⟨(P24 hx₁ hi hy₁).1, (P24 hx₁ hi hy₂).1, P3_comm.2 <\| ((P24 hy₁ hy₂ hx₂).2 hy).1 _, ih _ (snd <\| IsOption.moveLeft i) hx₁ hi⟩ · have hi := hx₁.neg.moveLeft i exact ⟨(P24 hx₂.neg hi hy₁).1, (P24 hx₂.neg hi hy₂).1, P3_comm.2 <\| ((P24 hy₁ hy₂ hx₁).2 hy).2 _, by rw [moveLeft_neg, ← P3_neg, neg_lt_neg_iff] exact ih _ (fst <\| IsOption.moveRight _) (hx₁.moveRight _) hx₂⟩	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	P3_of_lt_of_lt	One additional inductive argument that supplies the last missing part of Theorem 8.
Numeric.mul_pos (hx₁ : x₁.Numeric) (hx₂ : x₂.Numeric) (hp₁ : 0 < x₁) (hp₂ : 0 < x₂) : 0 < x₁ * x₂ := by rw [lt_iff_game_lt] have := P3_of_lt_of_lt numeric_zero hx₁ numeric_zero hx₂ hp₁ hp₂ simp_rw [P3, quot_zero_mul, quot_mul_zero, add_lt_add_iff_left] at this exact this	theorem	SetTheory	[ "Mathlib.Logic.Hydra", "Mathlib.SetTheory.Surreal.Basic", "Mathlib.Tactic.Linter.DeprecatedModule" ]	Mathlib/SetTheory/Surreal/Multiplication.lean	Numeric.mul_pos	null
@[pp_with_univ] ZFSet : Type (u + 1) := Quotient PSet.setoid.{u}	def	SetTheory	[ "Mathlib.Data.Fin.VecNotation", "Mathlib.Data.SetLike.Basic", "Mathlib.Logic.Small.Basic", "Mathlib.SetTheory.ZFC.PSet" ]	Mathlib/SetTheory/ZFC/Basic.lean	ZFSet	The ZFC universe of sets consists of the type of pre-sets, quotiented by extensional equivalence.
mk : PSet → ZFSet := Quotient.mk'' @[simp]	def	SetTheory	[ "Mathlib.Data.Fin.VecNotation", "Mathlib.Data.SetLike.Basic", "Mathlib.Logic.Small.Basic", "Mathlib.SetTheory.ZFC.PSet" ]	Mathlib/SetTheory/ZFC/Basic.lean	mk	Turns a pre-set into a ZFC set.
mk_eq (x : PSet) : @Eq ZFSet ⟦x⟧ (mk x) := rfl @[simp]	theorem	SetTheory	[ "Mathlib.Data.Fin.VecNotation", "Mathlib.Data.SetLike.Basic", "Mathlib.Logic.Small.Basic", "Mathlib.SetTheory.ZFC.PSet" ]	Mathlib/SetTheory/ZFC/Basic.lean	mk_eq	null
mk_out : ∀ x : ZFSet, mk x.out = x := Quotient.out_eq	theorem	SetTheory	[ "Mathlib.Data.Fin.VecNotation", "Mathlib.Data.SetLike.Basic", "Mathlib.Logic.Small.Basic", "Mathlib.SetTheory.ZFC.PSet" ]	Mathlib/SetTheory/ZFC/Basic.lean	mk_out	null
Definable (n) (f : (Fin n → ZFSet.{u}) → ZFSet.{u}) where /-- Turns a definable function into an n-ary `PSet` function. -/ out : (Fin n → PSet.{u}) → PSet.{u} /-- A set function `f` is the image of `Definable.out f`. -/ mk_out xs : mk (out xs) = f (mk <\| xs ·) := by simp attribute [simp] Definable.mk_out	class	SetTheory	[ "Mathlib.Data.Fin.VecNotation", "Mathlib.Data.SetLike.Basic", "Mathlib.Logic.Small.Basic", "Mathlib.SetTheory.ZFC.PSet" ]	Mathlib/SetTheory/ZFC/Basic.lean	Definable	A set function is "definable" if it is the image of some n-ary `PSet` function. This isn't exactly definability, but is useful as a sufficient condition for functions that have a computable image.
Definable₁ (f : ZFSet.{u} → ZFSet.{u}) := Definable 1 (fun s ↦ f (s 0))	abbrev	SetTheory	[ "Mathlib.Data.Fin.VecNotation", "Mathlib.Data.SetLike.Basic", "Mathlib.Logic.Small.Basic", "Mathlib.SetTheory.ZFC.PSet" ]	Mathlib/SetTheory/ZFC/Basic.lean	Definable₁	An abbrev of `ZFSet.Definable` for unary functions.

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.