math / data /lean /OAI /Dynamics /ConditionalShuffle /Disintegration.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
58.2 kB
import OAI.Probability.ThorpShuffle.Main namespace OAI noncomputable section open scoped BigOperators open Filter namespace Revealed open Thorp open scoped Classical def outside (d : ℕ) : Position d → Position (d + 1) := fun x => Fin.cons true x def freeLabel (d : ℕ) : Position d → Position (d + 1) := fun x => Fin.cons false x lemma freeLabel_injective (d : ℕ) : Function.Injective (freeLabel d) := by intro x y h exact congrArg Fin.tail h def imageRank {α β : Type*} [Fintype α] [LinearOrder β] (f : α → β) (hf : Function.Injective f) : α ≃ Fin (Fintype.card α) := by classical let e := Equiv.ofInjective f hf exact e.trans (Fintype.orderIsoFinOfCardEq (Set.range f) (Fintype.card_congr e).symm).toEquiv.symm def freeRank (d : ℕ) (g : State (d + 1)) : Position d ≃ Fin (2 ^ d) := (imageRank (fun x => toLex (g (freeLabel d x))) (by intro x y h; exact congrArg Fin.tail (g.injective h))).trans (finCongr (by simp [Position])) def layoutPath (d : ℕ) (g₀ : State d) : (t : ℕ) → History d t → Fin (t + 1) → State d | 0, _ => fun _ => g₀ | t + 1, ω => Fin.snoc (layoutPath d g₀ t (Fin.init ω)) (run d (t + 1) ω * g₀) abbrev Environment (d t : ℕ) := Fin (t + 1) → Position d → Position (d + 1) def outsidePaths (d t : ℕ) (g₀ : State (d + 1)) (ω : History (d + 1) t) : Environment d t := fun s x => layoutPath (d + 1) g₀ t ω s (outside d x) def slotPermutation (d t : ℕ) (g₀ : State (d + 1)) (ω : History (d + 1) t) : Equiv.Perm (Fin (2 ^ d)) := (freeRank d g₀).symm.trans (freeRank d (run (d + 1) t ω * g₀)) def environmentMass (d t : ℕ) (g₀ : State (d + 1)) : Environment d t → ℝ := fairMass (outsidePaths d t g₀) def conditionalLaw (d t : ℕ) (g₀ : State (d + 1)) (e : Environment d t) (g : Equiv.Perm (Fin (2 ^ d))) : ℝ := fairMass (fun ω : History (d + 1) t => (outsidePaths d t g₀ ω, slotPermutation d t g₀ ω)) (e, g) / environmentMass d t g₀ e def expectedTV (d t : ℕ) (g₀ : State (d + 1)) : ℝ := ∑ e, environmentMass d t g₀ e * tv (conditionalLaw d t g₀ e) (fun _ => 1 / (Nat.factorial (2 ^ d) : ℝ)) def worstConditionalTV (d t : ℕ) : ℝ := Finset.univ.sup' Finset.univ_nonempty (expectedTV d t) def twoHalfL : ℕ := 2 ^ 23 def twoHalfP : ℝ := 1 - 1 / (((2 : ℕ) : ℝ) * (twoHalfL : ℝ)) def twoHalfC : ℝ := -(1 / ((8 : ℕ) : ℝ)) * Real.logb ((2 : ℕ) : ℝ) ((3 + twoHalfP) / ((4 : ℕ) : ℝ)) def twoHalfB : ℕ := ⌈((10 : ℕ) : ℝ) / twoHalfC⌉₊ end Revealed namespace Thorp.Conditional open scoped Classical def exposedPath {ι : Type*} (d : ℕ) (e : ι → Position d) : (t : ℕ) → History d t → Fin (t + 1) → ι → Position d | 0, _ => fun _ => e | t + 1, ω => Fin.snoc (exposedPath d e t (Fin.init ω)) (run d (t + 1) ω ∘ e) @[simp] lemma exposedPath_last {ι : Type*} (d t : ℕ) (e : ι → Position d) (ω : History d t) : exposedPath d e t ω (Fin.last t) = run d t ω ∘ e := by cases t with | zero => simp [exposedPath, run_zero] | succ t => exact Fin.snoc_last _ _ @[simp] lemma exposedPath_snoc {ι : Type*} (d t : ℕ) (e : ι → Position d) (ω : History d t) (c : Coins d) : exposedPath d e (t + 1) (Fin.snoc ω c) = Fin.snoc (exposedPath d e t ω) ((step d c * run d t ω) ∘ e) := by simp only [exposedPath, Fin.init_snoc, run_snoc] theorem flow_path_joint_identity {ι : Type*} (d : ℕ) (v : RawState (d + 1)) (e : ι → Position (d + 1)) (he : ∀ i, v.free (e i) = false) (t : ℕ) (f : (Fin (t + 1) → ι → Position (d + 1)) → Position (d + 1) → ℝ) : mean (fun ω : History (d + 1) t => ∑ x, v.weight x * f (exposedPath (d + 1) e t ω) (run (d + 1) t ω x)) = mean (fun ω : History (d + 1) t => ∑ y, (rawIterate d v t ω).weight y * f (exposedPath (d + 1) e t ω) y) := by induction t with | zero => simp only [run_zero, rawIterate]; rfl | succ t ih => let F (p : Fin (t + 1) → ι → Position (d + 1)) (x : Position (d + 1)) : ℝ := mean (fun c : Coins (d + 1) => f (Fin.snoc p ((step (d + 1) c) ∘ p (Fin.last t))) (step (d + 1) c x)) have hleft : mean (fun ω : History (d + 1) (t + 1) => ∑ x, v.weight x * f (exposedPath (d + 1) e (t + 1) ω) (run (d + 1) (t + 1) ω x)) = mean (fun ω : History (d + 1) t => ∑ x, v.weight x * F (exposedPath (d + 1) e t ω) (run (d + 1) t ω x)) := by rw [mean_history_succ] apply mean_congr intro ω simp only [run_snoc, exposedPath_snoc] rw [mean_sum] simp_rw [mean_const_mul] simp only [F, exposedPath_last] rfl have hright : mean (fun ω : History (d + 1) (t + 1) => ∑ y, (rawIterate d v (t + 1) ω).weight y * f (exposedPath (d + 1) e (t + 1) ω) y) = mean (fun ω : History (d + 1) t => ∑ y, (rawIterate d v t ω).weight y * F (exposedPath (d + 1) e t ω) y) := by rw [mean_history_succ] apply mean_congr intro ω simp only [exposedPath_snoc, rawIterate_snoc] change mean (fun c : Position d → Bool => ∑ y, physicalFlow d (rawIterate d v t ω).free (rawIterate d v t ω).weight c y * f (Fin.snoc (exposedPath (d + 1) e t ω) ((step (d + 1) c) ∘ ((run (d + 1) t ω) ∘ e))) y) = _ rw [physicalFlow_joint d (rawIterate d v t ω).free (rawIterate d v t ω).weight ((run (d + 1) t ω) ∘ e) (by intro i simp only [Function.comp_apply, rawIterate_free, Equiv.symm_apply_apply] exact he i) (fun e' y => f (Fin.snoc (exposedPath (d + 1) e t ω) e') y)] rw [mean_sum] simp_rw [mean_const_mul] simp only [F, exposedPath_last] rfl exact hleft.trans ((ih F).trans hright.symm) end Thorp.Conditional namespace Thorp.Conditional open scoped Classical theorem halfDensity_after_step_sixteen (d : ℕ) (v : RawState (d + 1)) (c : Coins (d + 1)) (h : Bool) (hm : Fintype.card (Position (d + 1)) ≤ 16 * freeCount v.free) (hc : freeCount v.free ≤ 4 * pairHalfCount (v.free ∘ (splitPosition d).symm) c h) : (1 / 32 : ℝ) ≤ startHalfDensity d (rawNext d v c) h := by unfold startHalfDensity rw [halfCount_after_step] have hn : Fintype.card (Position (d + 1)) = 2 * Fintype.card (Position d) := by simp [Fintype.card_pi, Fintype.card_bool, Fintype.card_fin, pow_succ, Nat.mul_comm] rw [hn] at hm have hm' : (2 : ℝ) * Fintype.card (Position d) ≤ 16 * (freeCount v.free : ℝ) := by exact_mod_cast hm have hc' : (freeCount v.free : ℝ) ≤ 4 * (pairHalfCount (v.free ∘ (splitPosition d).symm) c h : ℝ) := by exact_mod_cast hc apply (le_div_iff₀ (by exact_mod_cast Fintype.card_pos (α := Position d))).mpr nlinarith theorem expectedNoise_dimension_sixteen (d : ℕ) (v : CenteredState (d + 2)) (hm : Fintype.card (Position (d + 2)) ≤ 16 * freeCount v.free) : expectedNoise (d + 1) v (d + 2) ≤ (31 / 32 : ℝ) * expectedEnergy (d + 1) v (d + 2) + 2 * (9 / 10 : ℝ) ^ freeCount v.free := by let B := v.free ∘ (splitPosition (d + 1)).symm let bad (c : Coins (d + 2)) : Prop := 4 * pairHalfCount B c false < pairFreeCount B ∨ 4 * pairHalfCount B c true < pairFreeCount B have hlocal (c : Coins (d + 2)) : expectedNoise (d + 1) (nextState (d + 1) v c) (d + 1) ≤ (31 / 32 : ℝ) * expectedEnergy (d + 1) (nextState (d + 1) v c) (d + 1) + (if bad c then 1 else 0) := by by_cases hc : bad c · rw [ite_eq_left hc] have hle := expectedNoise_le_energy (d + 1) (nextState (d + 1) v c) (d + 1) have hone := expectedEnergy_le_one (d + 1) (nextState (d + 1) v c) (d + 1) linarith · rw [ite_eq_right hc, add_zero] have hb (h : Bool) : (1 / 32 : ℝ) ≤ startHalfDensity (d + 1) (nextState (d + 1) v c).raw h := by apply halfDensity_after_step_sixteen (d + 1) v.raw c h hm have hf : ¬ 4 * pairHalfCount B c false < freeCount v.free := by simpa only [B, pairFreeCount_physical] using not_or.mp hc |>.1 have ht : ¬ 4 * pairHalfCount B c true < freeCount v.free := by simpa only [B, pairFreeCount_physical] using not_or.mp hc |>.2 change freeCount v.free ≤ 4 * pairHalfCount B c h cases h · exact Nat.le_of_not_gt hf · exact Nat.le_of_not_gt ht convert noise_bound_balanced_state d (nextState (d + 1) v c) (1 / 32) hb using 1; norm_num have hmean := mean_le_mean hlocal rw [mean_add, mean_const_mul, ← expectedNoise_first, ← expectedEnergy_first] at hmean have hbad := pair_both_half_balance B have hbad' : mean (fun c : Coins (d + 2) => if bad c then (1 : ℝ) else 0) ≤ 2 * (9 / 10 : ℝ) ^ freeCount v.free := by change mean (fun c : Position (d + 1) → Bool => if bad c then (1 : ℝ) else 0) ≤ _ simpa only [bad, B, pairFreeCount_physical] using hbad exact hmean.trans (add_le_add (le_refl _) hbad') theorem expectedNoise_bound_sixteen (d : ℕ) (v : CenteredState (d + 2)) (hm : Fintype.card (Position (d + 2)) ≤ 16 * freeCount v.free) (s : ℕ) (hs : d + 2 ≤ s) : expectedNoise (d + 1) v s ≤ (31 / 32 : ℝ) * expectedEnergy (d + 1) v s + 2 * (9 / 10 : ℝ) ^ freeCount v.free := by obtain ⟨a, rfl⟩ := Nat.exists_eq_add_of_le hs rw [Nat.add_comm (d + 2) a, expectedNoise_add, expectedEnergy_add] have he := mean_le_mean (fun ω : History (d + 2) a => expectedNoise_dimension_sixteen d (iterateState (d + 1) v a ω) (by simpa only [iterateState_freeCount] using hm)) simpa only [iterateState_freeCount, mean_add, mean_const_mul, mean_const] using he lemma sixteen_density_geometric_choice : (63 / 64 : ℝ) ^ 398 ≤ (1 / 2 : ℝ) ^ 8 := by have h : (63 / 64 : ℝ) ^ 199 ≤ 1 / 16 := by norm_num calc _ = ((63 / 64 : ℝ) ^ 199) ^ 2 := by rw [← pow_mul] _ ≤ (1 / 16 : ℝ) ^ 2 := pow_le_pow_left₀ (by positivity) h 2 _ = _ := by norm_num theorem expectedEnergy_decay_sixteen (d : ℕ) (v : CenteredState (d + 2)) (hm : Fintype.card (Position (d + 2)) ≤ 16 * freeCount v.free) (t : ℕ) : expectedEnergy (d + 1) v t ≤ (63 / 64 : ℝ) ^ t / (63 / 64 : ℝ) ^ (2 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ freeCount v.free := by have he := scalar_decay (d + 2) (expectedEnergy (d + 1) v) (expectedNoise (d + 1) v) (1 / 32) (63 / 64) (2 * (9 / 10 : ℝ) ^ freeCount v.free) (by norm_num) (by norm_num) (by norm_num) (by norm_num) (by norm_num) (by positivity) (expectedEnergy_le_one (d + 1) v) (expectedEnergy_recurrence (d + 1) v) (by intro s hs; convert expectedNoise_bound_sixteen d v hm s hs using 1; norm_num) t convert he using 1; ring theorem expectedEnergy_400 (d : ℕ) (v : CenteredState (d + 2)) (hm : Fintype.card (Position (d + 2)) ≤ 16 * freeCount v.free) : expectedEnergy (d + 1) v (400 * (d + 2)) ≤ (1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ freeCount v.free := by have he := expectedEnergy_decay_sixteen d v hm (400 * (d + 2)) have hp : (63 / 64 : ℝ) ^ (400 * (d + 2)) / (63 / 64 : ℝ) ^ (2 * (d + 2)) = (63 / 64 : ℝ) ^ (398 * (d + 2)) := by have hn : 400 * (d + 2) = 398 * (d + 2) + 2 * (d + 2) := by omega rw [hn, pow_add, mul_div_cancel_right₀ _ (by positivity)] rw [hp] at he have hpow := pow_le_pow_left₀ (by positivity : (0 : ℝ) ≤ (63 / 64) ^ 398) sixteen_density_geometric_choice (d + 2) rw [← pow_mul, ← pow_mul] at hpow exact he.trans (add_le_add hpow (le_refl _)) theorem centeredPoint_energy_400 (d : ℕ) (B : Position (d + 2) → Bool) (tag : Position (d + 2)) (ht : B tag = true) (hm : Fintype.card (Position (d + 2)) ≤ 16 * freeCount B) : expectedEnergy (d + 1) (initialState (d + 2) B tag ht) (400 * (d + 2)) ≤ (1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ freeCount B := expectedEnergy_400 d _ hm end Thorp.Conditional namespace Thorp.Fourier open scoped Classical InnerProductSpace variable {G H : Type} [Group G] [Fintype G] [Group H] [Fintype H] def realProduct : (n : ℕ) → (Fin n → G → ℝ) → G → ℝ | 0, _ => fun g => if g = 1 then 1 else 0 | n + 1, ν => realConv (ν (Fin.last n)) (realProduct n (Fin.init ν)) lemma realProduct_nonneg (n : ℕ) (ν : Fin n → G → ℝ) (hν : ∀ i g, 0 ≤ ν i g) : ∀ g, 0 ≤ realProduct n ν g := by induction n with | zero => intro g; simp only [realProduct]; split_ifs <;> norm_num | succ n ih => exact realConv_nonneg _ _ (hν _) (ih _ (fun i => hν i.castSucc)) lemma realProduct_sum (n : ℕ) (ν : Fin n → G → ℝ) (hν : ∀ i, ∑ g, ν i g = 1) : ∑ g, realProduct n ν g = 1 := by induction n with | zero => simp [realProduct] | succ n ih => rw [realProduct, realConv_sum, hν, ih (Fin.init ν) (fun i => hν i.castSucc), mul_one] lemma realConv_character (χ : G →* ℂ) (μ ν : G → ℝ) : (∑ g, (realConv μ ν g : ℂ) * χ g) = (∑ g, (μ g : ℂ) * χ g) * (∑ g, (ν g : ℂ) * χ g) := by simp only [realConv, Complex.ofReal_sum, Complex.ofReal_mul, Finset.sum_mul] rw [Finset.sum_comm] apply Finset.sum_congr rfl intro h _ rw [Finset.mul_sum] have he := Equiv.sum_comp (Equiv.mulLeft h) (fun g => (μ h : ℂ) * (ν (h⁻¹ * g) : ℂ) * χ g) change (∑ g, (μ h : ℂ) * (ν (h⁻¹ * (h * g)) : ℂ) * χ (h * g)) = _ at he simp only [inv_mul_cancel_left, map_mul] at he rw [← he] apply Finset.sum_congr rfl intro g _ ring lemma realProduct_character_bound (χ : G →* ℂ) (n : ℕ) (ν : Fin n → G → ℝ) (η : ℝ) (hη : 0 ≤ η) (hb : ∀ i, ‖∑ g, (ν i g : ℂ) * χ g‖ ≤ η) : ‖∑ g, (realProduct n ν g : ℂ) * χ g‖ ≤ η ^ n := by induction n with | zero => simp [realProduct, apply_ite (fun x : ℝ => (x : ℂ)), ite_mul] | succ n ih => rw [realProduct, realConv_character, norm_mul, pow_succ'] exact mul_le_mul (hb _) (ih _ (fun i => hb i.castSucc)) (norm_nonneg _) hη variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [finiteDimensional_ℂ_E : FiniteDimensional ℂ E] lemma realProduct_transform_norm (ρ : Representation ℂ G E) (n : ℕ) (ν : Fin n → G → ℝ) (R : ℝ) (hR : 0 ≤ R) (hν : ∀ i v, ‖integrated ρ (fun g => (ν i g : ℂ)) v‖ ^ 2 ≤ R * ‖v‖ ^ 2) (v : E) : ‖integrated ρ (fun g => (realProduct n ν g : ℂ)) v‖ ^ 2 ≤ R ^ n * ‖v‖ ^ 2 := by let retained_finiteDimensional_ℂ_E := finiteDimensional_ℂ_E induction n with | zero => have he : (fun g : G => (realProduct 0 ν g : ℂ)) = delta := by funext g; simp only [realProduct, delta]; split_ifs <;> norm_num rw [he, integrated_delta] simp | succ n ih => rw [realProduct, integrated_realConv, Module.End.mul_apply, pow_succ' R n, mul_assoc] exact (hν (Fin.last n) _).trans (mul_le_mul_of_nonneg_left (ih (Fin.init ν) (fun i => hν i.castSucc)) hR) lemma realProduct_hsSq (ρ : Representation ℂ G E) (n : ℕ) (ν : Fin n → G → ℝ) (R : ℝ) (hR : 0 ≤ R) (hν : ∀ i v, ‖integrated ρ (fun g => (ν i g : ℂ)) v‖ ^ 2 ≤ R * ‖v‖ ^ 2) : hsSq (integrated ρ (fun g => (realProduct n ν g : ℂ))) ≤ (Module.finrank ℂ E : ℝ) * R ^ n := by unfold hsSq calc _ ≤ ∑ i, R ^ n * ‖stdOrthonormalBasis ℂ E i‖ ^ 2 := Finset.sum_le_sum (fun i _ => realProduct_transform_norm ρ n ν R hR hν _) _ = _ := by simp [(stdOrthonormalBasis ℂ E).norm_eq_one, mul_comm] lemma Family.eight_sequence_transform_bound (F : Family H) (ρ : Representation ℂ G E) [Representation.IsIrreducible ρ] (hu : ∀ g x y, ⟪ρ g x, ρ g y⟫_ℂ = ⟪x, y⟫_ℂ) (hd : 0 < Module.finrank ℂ E) (ψ : (Fin 8 → H) →* G) (ν : Fin 8 → G → ℝ) (B : ℝ) (hν : ∀ j g, 0 ≤ ν j g) (h1 : ∀ j, ∑ g, ν j g = 1) (hB : 0 ≤ B) (hcoset : ∀ j i g, ∑ h, ν j (g * ψ (Pi.mulSingle i h)) ≤ B * (Fintype.card H : ℝ) / Fintype.card G) : (Module.finrank ℂ E : ℝ) * hsSq (integrated ρ (fun g => (realProduct 8 ν g : ℂ))) ≤ (8 * B * F.reciprocalSum)^8 * ((Module.finrank ℂ E : ℝ)^2)⁻¹ := by let S : ℝ := ∑ b ∈ Finset.univ.filter (fun b => F.degree b ^ 8 ≤ Module.finrank ℂ E), (F.degree b : ℝ)^2 let R : ℝ := 8 * B * S / Module.finrank ℂ E have hD : (0 : ℝ) < Module.finrank ℂ E := by exact_mod_cast hd have hR : 0 ≤ R := by dsimp [R, S]; positivity have hA (j : Fin 8) (v : E) : ‖integrated ρ (fun g => (ν j g : ℂ)) v‖ ^ 2 ≤ R * ‖v‖ ^ 2 := by simpa only [R, S, Fintype.card_fin, Nat.cast_ofNat] using F.integrated_norm_sq ρ hu (Nat.ne_of_gt hd) ψ (ν j) B (hν j) (h1 j) hB (by intro i g convert hcoset j i g using 1 apply Finset.sum_congr rfl intro h _ congr 4 exact Subsingleton.elim _ _) v calc _ ≤ (Module.finrank ℂ E : ℝ) * ((Module.finrank ℂ E : ℝ) * R^8) := mul_le_mul_of_nonneg_left (realProduct_hsSq ρ 8 ν R hR hA) hD.le _ = (Module.finrank ℂ E : ℝ)^2 * R^8 := by ring _ ≤ _ := eight_degree_bound _ hD B S F.reciprocalSum (F.low_degree_sq _) end Thorp.Fourier namespace Thorp.Fourier variable {G : Type} [Group G] [Fintype G] variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] lemma centered_probability_trivial (ρ : Representation ℂ G E) (hρ : ∀ g v, ρ g v = v) (ν : G → ℝ) (h1 : ∑ g, ν g = 1) : integrated ρ (fun g => ((ν g - (Fintype.card G : ℝ)⁻¹ : ℝ) : ℂ)) = 0 := by rw [integrated_real_sub] have htr (g : G) (v : E) : ρ g v = (1 : ℂ) • v := by simpa using hρ g v rw [integrated_scalar ρ (fun _ => 1) htr, integrated_scalar ρ (fun _ => 1) htr] simp only [mul_one, ← Complex.ofReal_sum, h1, Complex.ofReal_one, Finset.sum_const, Finset.card_univ, nsmul_eq_mul] simp [Complex.ofReal_inv, Complex.ofReal_natCast, Fintype.card_ne_zero] lemma centered_probability_character (ρ : Representation ℂ G E) (χ : G → ℂ) (hρ : ∀ g v, ρ g v = χ g • v) (hχ : ∑ g, χ g = 0) (ν : G → ℝ) : integrated ρ (fun g => ((ν g - (Fintype.card G : ℝ)⁻¹ : ℝ) : ℂ)) = (∑ g, (ν g : ℂ) * χ g) • LinearMap.id := by rw [integrated_real_sub, integrated_scalar ρ χ hρ, integrated_scalar ρ χ hρ] simp only [← Finset.mul_sum, hχ, mul_zero, zero_smul, sub_zero] end Thorp.Fourier namespace Thorp.Specht open scoped Classical open Thorp.Fourier variable {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] [Nontrivial α] theorem permutation_eight_sequence_bound (hn : 16 ≤ Fintype.card α) (ψ : (Fin 8 → Equiv.Perm β) →* Equiv.Perm α) (ν : Fin 8 → Equiv.Perm α → ℝ) (B : ℝ) (hν : ∀ j g, 0 ≤ ν j g) (h1 : ∀ j, ∑ g, ν j g = 1) (hB : 0 ≤ B) (hcoset : ∀ j i g, ∑ h, ν j (g * ψ (Pi.mulSingle i h)) ≤ B * (Fintype.card (Equiv.Perm β) : ℝ) / Fintype.card (Equiv.Perm α)) : (∑ g, |realProduct 8 ν g - (Fintype.card (Equiv.Perm α) : ℝ)⁻¹|)^2 ≤ 2 * ‖∑ g, (realProduct 8 ν g : ℂ) * complexSign g‖^2 + (8 * B * (permutationFamily β).reciprocalSum)^8 * exceptionalReciprocalSum (Fintype.card α) := by let F := permutationFamily α let H := permutationFamily β let bias : ℝ := ‖∑ g, (realProduct 8 ν g : ℂ) * complexSign g‖^2 let K : ℝ := (8 * B * H.reciprocalSum)^8 let f : Equiv.Perm α → ℝ := fun g => realProduct 8 ν g - (Fintype.card (Equiv.Perm α) : ℝ)⁻¹ have hp (p : F.Index) : (F.degree p : ℝ) * hsSq (integrated (F.rep p) (fun g => (f g : ℂ))) ≤ if defect p = 0 then bias else K * inverseDegree p := by by_cases hz : defect p = 0 · rw [ite_eq_left hz] obtain ⟨hd, htr | hsign⟩ := permutation_exceptional_action (α:=α) p hz · have hh := centered_probability_trivial (F.rep p) htr (realProduct 8 ν) (realProduct_sum _ _ h1) change integrated (F.rep p) (fun g => (f g : ℂ)) = 0 at hh rw [hh] simp only [hsSq, LinearMap.zero_apply, norm_zero, zero_pow (by decide : 2 ≠ 0), Finset.sum_const_zero, mul_zero] exact pow_nonneg (norm_nonneg _) _ · have hh := centered_probability_character (F.rep p) complexSign hsign (complexSign_sum (α:=α)) (realProduct 8 ν) change integrated (F.rep p) (fun g => (f g : ℂ)) = _ at hh rw [hh, hsSq_scalar] change (F.degree p : ℝ) * ((F.degree p : ℝ) * ‖∑ g, (realProduct 8 ν g : ℂ) * complexSign g‖^2) ≤ bias rw [show F.degree p = 1 from hd] simp only [Nat.cast_one, one_mul] exact le_rfl · rw [ite_eq_right hz] have hgt : 1 < Module.finrank ℂ (F.Space p) := degree_gt_one p hn (Nat.pos_of_ne_zero hz) have hu := integrated_uniform_real (F.rep p) hgt have he : integrated (F.rep p) (fun g => (f g : ℂ)) = integrated (F.rep p) (fun g => (realProduct 8 ν g : ℂ)) := by rw [show (fun g => (f g : ℂ)) = (fun g => ((realProduct 8 ν g - (Fintype.card (Equiv.Perm α) : ℝ)⁻¹ : ℝ) : ℂ)) from rfl, integrated_real_sub, hu, sub_zero] rw [he] exact H.eight_sequence_transform_bound (F.rep p) (F.unitary p) (by omega) ψ ν B hν h1 hB hcoset have hs : (∑ p : NShape (Fintype.card α), if defect p = 0 then bias else K * inverseDegree p) = (Fintype.card {p : NShape (Fintype.card α) // defect p = 0} : ℝ) * bias + K * exceptionalReciprocalSum (Fintype.card α) := by rw [show (Fintype.card {p : NShape (Fintype.card α) // defect p = 0} : ℝ) * bias = ∑ p : NShape (Fintype.card α), if defect p = 0 then bias else 0 by rw [← Finset.sum_filter]; simp [Fintype.card_subtype], exceptionalReciprocalSum, Finset.mul_sum, ← Finset.sum_add_distrib] apply Finset.sum_congr rfl intro p _ by_cases hz : defect p = 0 · simp only [hz, lt_self_iff_false, ↓reduceIte, mul_zero, add_zero] · simp only [hz, Nat.pos_of_ne_zero hz, ↓reduceIte, zero_add] have hc : (Fintype.card {p : NShape (Fintype.card α) // defect p = 0} : ℝ) ≤ 2 := by exact_mod_cast exceptional_count (Fintype.card α) calc _ ≤ ∑ p, (F.degree p : ℝ) * hsSq (integrated (F.rep p) (fun g => (f g : ℂ))) := F.l1_sq_le_parseval f _ ≤ ∑ p : NShape (Fintype.card α), if defect p = 0 then bias else K * inverseDegree p := Finset.sum_le_sum (fun p _ => hp p) _ = _ := hs _ ≤ _ := add_le_add (mul_le_mul_of_nonneg_right hc (pow_nonneg (norm_nonneg _) _)) le_rfl end Thorp.Specht namespace Thorp.Conditional open scoped Classical theorem tagged_path_deviation_identity {ι : Type*} (d : ℕ) (B : Position (d + 1) → Bool) (tag : Position (d + 1)) (ht : B tag = true) (e : ι → Position (d + 1)) (he : ∀ i, B (e i) = false) (t : ℕ) (f : (Fin (t + 1) → ι → Position (d + 1)) → Position (d + 1) → ℝ) : mean (fun ω : History (d + 1) t => f (exposedPath (d + 1) e t ω) (run (d + 1) t ω tag) - (1 / (freeCount B : ℝ)) * (∑ y, if B ((run (d + 1) t ω).symm y) then f (exposedPath (d + 1) e t ω) y else 0)) = mean (fun ω : History (d + 1) t => ∑ y, (iterateState d (initialState (d + 1) B tag ht) t ω).weight y * f (exposedPath (d + 1) e t ω) y) := by have hh := flow_path_joint_identity d (initialState (d + 1) B tag ht).raw e he t f simp_rw [← iterateState_raw] at hh change (mean (fun ω : History (d + 1) t => ∑ x, (initialState (d + 1) B tag ht).weight x * f (exposedPath (d + 1) e t ω) (run (d + 1) t ω x))) = _ at hh change _ = mean (fun ω : History (d + 1) t => ∑ y, (iterateState d (initialState (d + 1) B tag ht) t ω).raw.weight y * f (exposedPath (d + 1) e t ω) y) rw [← hh] apply mean_congr intro ω change _ = ∑ x, centeredPoint B tag x * f (exposedPath (d + 1) e t ω) (run (d + 1) t ω x) rw [centeredPoint_test] congr 2 simpa only [Equiv.symm_apply_apply] using (Equiv.sum_comp (run (d + 1) t ω) (fun y => if B ((run (d + 1) t ω).symm y) then f (exposedPath (d + 1) e t ω) y else 0)).symm theorem tagged_path_deviation_bound {ι : Type*} (d : ℕ) (B : Position (d + 1) → Bool) (tag : Position (d + 1)) (ht : B tag = true) (e : ι → Position (d + 1)) (he : ∀ i, B (e i) = false) (t : ℕ) (f : (Fin (t + 1) → ι → Position (d + 1)) → Position (d + 1) → ℝ) (hf : ∀ e' y, |f e' y| ≤ 1) : |mean (fun ω : History (d + 1) t => f (exposedPath (d + 1) e t ω) (run (d + 1) t ω tag) - (1 / (freeCount B : ℝ)) * (∑ y, if B ((run (d + 1) t ω).symm y) then f (exposedPath (d + 1) e t ω) y else 0))| ≤ Real.sqrt ((Fintype.card (Position (d + 1)) : ℝ) * expectedEnergy d (initialState (d + 1) B tag ht) t) := by rw [tagged_path_deviation_identity d B tag ht e he] exact mean_weighted_test_le _ _ (fun ω y => hf _ y) end Thorp.Conditional namespace Thorp.Conditional open scoped Classical def avoid {ι α : Type*} (e : ι → α) : α → Bool := fun x => decide (∀ i, e i ≠ x) @[simp] lemma avoid_exposed {ι α : Type*} (e : ι → α) (i : ι) : avoid e (e i) = false := by simp [avoid] lemma avoid_perm {ι α : Type*} (e : ι → α) (g : Equiv.Perm α) (x : α) : avoid (g ∘ e) x = avoid e (g.symm x) := by simp [avoid, ← g.eq_symm_apply] lemma avoid_equiv_left {ι α β : Type*} (L : Sum ι α ≃ β) {k : ℕ} (e : Fin k → α) (i : ι) : avoid (Sum.elim (fun j => L (.inl j)) (fun j => L (.inr (e j)))) (L (.inl i)) = false := by exact avoid_exposed (Sum.elim (fun j => L (.inl j)) (fun j => L (.inr (e j)))) (Sum.inl i) lemma avoid_equiv_right {ι α β : Type*} [DecidableEq α] (L : Sum ι α ≃ β) {k : ℕ} (e : Fin k → α) (a : α) : avoid (Sum.elim (fun j => L (.inl j)) (fun j => L (.inr (e j)))) (L (.inr a)) = freeOf e a := by simp [avoid, freeOf, Sum.forall] lemma freeCount_avoid_equiv {ι α β : Type*} [Fintype ι] [Fintype α] [Fintype β] [DecidableEq α] (L : Sum ι α ≃ β) {k : ℕ} (e : Fin k → α) : freeCount (avoid (Sum.elim (fun i => L (.inl i)) (fun j => L (.inr (e j))))) = freeCount (freeOf e) := by apply Nat.cast_injective (R := ℝ) rw [← sum_free_indicator, ← sum_free_indicator] rw [← Equiv.sum_comp L] simp only [Fintype.sum_sum_type, avoid_equiv_left, Bool.false_eq_true, ↓reduceIte, Finset.sum_const_zero, avoid_equiv_right, zero_add] def pathComplete {ι α : Type*} [Fintype α] {t k : ℕ} (f : (Fin (t + 1) → ι → α) → (Fin (k + 1) → α) → ℝ) (p : Fin (t + 1) → ι → α) (z : Fin k → α) : ℝ := let B := avoid (Sum.elim (p (Fin.last t)) z) (1 / (freeCount B : ℝ)) * ∑ y, if B y then f p (Fin.snoc z y) else 0 lemma pathComplete_bound {ι α : Type*} [Fintype α] {t k : ℕ} (f : (Fin (t + 1) → ι → α) → (Fin (k + 1) → α) → ℝ) (hf : ∀ p z, |f p z| ≤ 1) (p : Fin (t + 1) → ι → α) (z : Fin k → α) : |pathComplete f p z| ≤ 1 := by let B := avoid (Sum.elim (p (Fin.last t)) z) change |(1 / (freeCount B : ℝ)) * ∑ y, if B y then f p (Fin.snoc z y) else 0| ≤ 1 rw [abs_mul, abs_of_nonneg (by positivity : (0 : ℝ) ≤ 1 / (freeCount B : ℝ))] have hs : |∑ y, if B y then f p (Fin.snoc z y) else 0| ≤ freeCount B := by calc _ ≤ ∑ y, |if B y then f p (Fin.snoc z y) else 0| := Finset.abs_sum_le_sum_abs _ _ _ ≤ ∑ y, if B y then (1 : ℝ) else 0 := Finset.sum_le_sum (fun y _ => by cases h : B y <;> simp only [Bool.false_eq_true, ↓reduceIte, abs_zero, le_refl] ; exact hf _ _) _ = _ := sum_free_indicator _ have hh := mul_le_mul_of_nonneg_left hs (by positivity : (0 : ℝ) ≤ 1 / (freeCount B : ℝ)) by_cases hz : freeCount B = 0 · simp [hz] · have hn : (freeCount B : ℝ) ≠ 0 := by exact_mod_cast hz simpa [hn] using hh lemma exposedPath_comp {ι κ : Type*} (d : ℕ) (e : ι → Position d) (a : κ → ι) (t : ℕ) (ω : History d t) : (fun s => exposedPath d e t ω s ∘ a) = exposedPath d (e ∘ a) t ω := by induction t with | zero => rfl | succ t ih => funext s j refine Fin.lastCases ?_ (fun i => ?_) s · simp [exposedPath, Function.comp_def] · simpa only [exposedPath, Fin.snoc_castSucc, Function.comp_apply] using congrFun (congrFun (ih (Fin.init ω)) i) j end Thorp.Conditional namespace Thorp.Conditional open scoped Classical lemma pathComplete_equiv {ι α β : Type*} [Fintype ι] [Fintype α] [Fintype β] [DecidableEq α] (L : Sum ι α ≃ β) {t k : ℕ} (f : (Fin (t + 1) → ι → β) → (Fin (k + 1) → β) → ℝ) (p : Fin (t + 1) → ι → β) (hp : p (Fin.last t) = fun i => L (.inl i)) (e : Fin k → α) : pathComplete f p (fun j => L (.inr (e j))) = (1 / (freeCount (freeOf e) : ℝ)) * ∑ a, if freeOf e a then f p (Fin.snoc (fun j => L (.inr (e j))) (L (.inr a))) else 0 := by unfold pathComplete dsimp only rw [hp, freeCount_avoid_equiv] congr 1 rw [← Equiv.sum_comp L] simp only [Fintype.sum_sum_type, avoid_equiv_left, Bool.false_eq_true, ↓reduceIte, Finset.sum_const_zero, avoid_equiv_right, zero_add] lemma uniform_path_completion {ι α β : Type*} [Fintype ι] [Fintype α] [Fintype β] [DecidableEq α] (L : Sum ι α ≃ β) {t k : ℕ} (f : (Fin (t + 1) → ι → β) → (Fin (k + 1) → β) → ℝ) (p : Fin (t + 1) → ι → β) (hp : p (Fin.last t) = fun i => L (.inl i)) (e : Fin k → α) (tag : α) (ht : freeOf e tag = true) : mean (fun σ : Equiv.Perm α => f p (Fin.snoc (fun j => L (.inr (σ (e j)))) (L (.inr (σ tag))))) = mean (fun σ : Equiv.Perm α => pathComplete f p (fun j => L (.inr (σ (e j))))) := by have hh := uniform_tagged_completion e tag ht (fun z y => f p (Fin.snoc (fun j => L (.inr (z j))) (L (.inr y)))) refine hh.trans ?_ apply mean_congr intro σ simpa only [freeCount_perm, Function.comp_apply] using (pathComplete_equiv L f p hp (σ ∘ e)).symm def splitPath {ι α : Type*} {d : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) (ω : History d t) : Fin (t + 1) → ι → Position d := exposedPath d (fun i => L (.inl i)) t ω def splitTuple {ι α : Type*} {d k : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) (ω : History d t) (e : Fin k → α) : Fin k → Position d := fun j => run d t ω (L (.inr (e j))) lemma splitTuple_snoc {ι α : Type*} {d k : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) (ω : History d t) (e : Fin k → α) (a : α) : splitTuple L t ω (Fin.snoc e a) = Fin.snoc (splitTuple L t ω e) (run d t ω (L (.inr a))) := by funext j refine Fin.lastCases ?_ (fun i => ?_) j <;> simp [splitTuple] lemma splitPath_last {ι α : Type*} {d : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) (ω : History d t) : splitPath L t ω (Fin.last t) = fun i => run d t ω (L (.inl i)) := exposedPath_last _ _ _ _ end Thorp.Conditional namespace Thorp.Conditional open scoped Classical lemma splitPath_completion_error {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] (d : ℕ) (L : Sum ι α ≃ Position (d + 1)) {k : ℕ} (e : Fin k → α) (tag : α) (ht : freeOf e tag = true) (t : ℕ) (f : (Fin (t + 1) → ι → Position (d + 1)) → (Fin (k + 1) → Position (d + 1)) → ℝ) (hf : ∀ p z, |f p z| ≤ 1) : |mean (fun ω : History (d + 1) t => f (splitPath L t ω) (splitTuple L t ω (Fin.snoc e tag))) - mean (fun ω : History (d + 1) t => pathComplete f (splitPath L t ω) (splitTuple L t ω e))| ≤ Real.sqrt ((Fintype.card (Position (d + 1)) : ℝ) * expectedEnergy d (initialState (d + 1) (avoid (Sum.elim (fun i => L (.inl i)) (fun j => L (.inr (e j))))) (L (.inr tag)) (by rwa [avoid_equiv_right])) t) := by let z : Sum ι (Fin k) → Position (d + 1) := Sum.elim (fun i => L (.inl i)) (fun j => L (.inr (e j))) let B := avoid z let F (p : Fin (t + 1) → Sum ι (Fin k) → Position (d + 1)) (y : Position (d + 1)) := f (fun s i => p s (.inl i)) (Fin.snoc (fun j => p (Fin.last t) (.inr j)) y) have hh := tagged_path_deviation_bound d B (L (.inr tag)) (by exact (avoid_equiv_right L e tag).trans ht) z (avoid_exposed z) t F (fun p y => hf _ _) have ho (ω : History (d + 1) t) : (fun s i => exposedPath (d + 1) z t ω s (.inl i)) = splitPath L t ω := exposedPath_comp (d + 1) z Sum.inl t ω have he (ω : History (d + 1) t) : (fun j => exposedPath (d + 1) z t ω (Fin.last t) (.inr j)) = splitTuple L t ω e := by rw [exposedPath_last] rfl have hF (ω : History (d + 1) t) (y : Position (d + 1)) : F (exposedPath (d + 1) z t ω) y = f (splitPath L t ω) (Fin.snoc (splitTuple L t ω e) y) := by change f _ _ = _ rw [ho, he] have hB (ω : History (d + 1) t) (y : Position (d + 1)) : B ((run (d + 1) t ω).symm y) = avoid (Sum.elim (splitPath L t ω (Fin.last t)) (splitTuple L t ω e)) y := by rw [splitPath_last] have hz : Sum.elim (fun i => run (d + 1) t ω (L (.inl i))) (splitTuple L t ω e) = (run (d + 1) t ω) ∘ z := by funext i cases i <;> rfl rw [hz] exact (avoid_perm z (run (d + 1) t ω) y).symm have hcount (ω : History (d + 1) t) : freeCount (avoid (Sum.elim (splitPath L t ω (Fin.last t)) (splitTuple L t ω e))) = freeCount B := by rw [splitPath_last] change freeCount (avoid (Sum.elim (fun i => (L.trans (run (d + 1) t ω)) (.inl i)) (fun j => (L.trans (run (d + 1) t ω)) (.inr (e j))))) = _ rw [freeCount_avoid_equiv, show freeCount B = freeCount (freeOf e) from freeCount_avoid_equiv L e] simp_rw [hF, hB] at hh rw [← mean_sub] convert hh using 1 congr 1 apply mean_congr intro ω rw [splitTuple_snoc] congr 1 exact congrArg (fun n : ℕ => (1 / (n : ℝ)) * ∑ y, if avoid (Sum.elim (splitPath L t ω (Fin.last t)) (splitTuple L t ω e)) y then f (splitPath L t ω) (Fin.snoc (splitTuple L t ω e) y) else 0) (hcount ω) end Thorp.Conditional namespace Thorp.Conditional open scoped Classical lemma uniform_splitTuple_completion {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] {d : ℕ} (L : Sum ι α ≃ Position d) {k : ℕ} (e : Fin (k + 1) → α) (he : Function.Injective e) (t : ℕ) (ω : History d t) (f : (Fin (t + 1) → ι → Position d) → (Fin (k + 1) → Position d) → ℝ) : mean (fun σ : Equiv.Perm α => f (splitPath L t ω) (splitTuple L t ω (σ ∘ e))) = mean (fun σ : Equiv.Perm α => pathComplete f (splitPath L t ω) (splitTuple L t ω (σ ∘ Fin.init e))) := by have ht : freeOf (Fin.init e) (e (Fin.last k)) = true := by apply (freeOf_true _ _).mpr intro i hi exact Fin.castSucc_ne_last i (he hi) have hh := uniform_path_completion (L.trans (run d t ω)) f (splitPath L t ω) (splitPath_last L t ω) (Fin.init e) (e (Fin.last k)) ht convert hh using 1 · apply mean_congr intro σ congr 1 funext j refine Fin.lastCases ?_ (fun i => ?_) j <;> simp [splitTuple, Fin.init_def] · rfl theorem splitTuple_test_400 {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] (d m : ℕ) (hm : Fintype.card (Position (d + 2)) ≤ 16 * m) (L : Sum ι α ≃ Position (d + 2)) (k : ℕ) (hk : k + m ≤ Fintype.card α) (e : Fin k → α) (he : Function.Injective e) (f : (Fin (400 * (d + 2) + 1) → ι → Position (d + 2)) → (Fin k → Position (d + 2)) → ℝ) (hf : ∀ p z, |f p z| ≤ 1) : |mean (fun ω : History (d + 2) (400 * (d + 2)) => f (splitPath L _ ω) (splitTuple L _ ω e)) - mean (fun ω : History (d + 2) (400 * (d + 2)) => mean (fun σ : Equiv.Perm α => f (splitPath L _ ω) (splitTuple L _ ω (σ ∘ e))))| ≤ (k : ℝ) * Real.sqrt ((Fintype.card (Position (d + 2)) : ℝ) * ((1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ m)) := by induction k with | zero => have hz (ω : History (d + 2) (400 * (d + 2))) (σ : Equiv.Perm α) : splitTuple L _ ω (σ ∘ e) = splitTuple L _ ω e := Subsingleton.elim _ _ simp_rw [hz, mean_const] simp | succ k ih => have he0 : Function.Injective (Fin.init e) := by intro i j hij exact Fin.castSucc_inj.mp (he hij) have ht : freeOf (Fin.init e) (e (Fin.last k)) = true := by apply (freeOf_true _ _).mpr intro i hi exact Fin.castSucc_ne_last i (he hi) let B := avoid (Sum.elim (fun i => L (.inl i)) (fun j => L (.inr (Fin.init e j)))) have htag : B (L (.inr (e (Fin.last k)))) = true := (avoid_equiv_right _ _ _).trans ht have hcount : m ≤ freeCount B := by rw [show freeCount B = freeCount (freeOf (Fin.init e)) from freeCount_avoid_equiv L (Fin.init e), freeCount_freeOf _ he0] omega have henergy := centeredPoint_energy_400 d B (L (.inr (e (Fin.last k)))) htag (by omega) have hpower : (9 / 10 : ℝ) ^ freeCount B ≤ (9 / 10 : ℝ) ^ m := pow_le_pow_of_le_one (by norm_num) (by norm_num) hcount have hz := splitPath_completion_error (d + 1) L (Fin.init e) (e (Fin.last k)) ht (400 * (d + 2)) f hf rw [Fin.snoc_init_self] at hz have hestimate : Real.sqrt ((Fintype.card (Position (d + 2)) : ℝ) * expectedEnergy (d + 1) (initialState (d + 2) B (L (.inr (e (Fin.last k)))) htag) (400 * (d + 2))) ≤ Real.sqrt ((Fintype.card (Position (d + 2)) : ℝ) * ((1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ m)) := by apply Real.sqrt_le_sqrt apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _) exact henergy.trans (by linarith) have hnext := ih (by omega) (Fin.init e) he0 (pathComplete f) (pathComplete_bound f hf) simp_rw [uniform_splitTuple_completion L e he _ _ f] have htri := abs_sub_le (mean (fun ω : History (d + 2) (400 * (d + 2)) => f (splitPath L _ ω) (splitTuple L _ ω e))) (mean (fun ω : History (d + 2) (400 * (d + 2)) => pathComplete f (splitPath L _ ω) (splitTuple L _ ω (Fin.init e)))) (mean (fun ω : History (d + 2) (400 * (d + 2)) => mean (fun σ : Equiv.Perm α => pathComplete f (splitPath L _ ω) (splitTuple L _ ω (σ ∘ Fin.init e))))) have hz' := hz.trans hestimate push_cast nlinarith end Thorp.Conditional namespace Thorp.Conditional open scoped Classical theorem splitTuple_joint_tv_400 {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] (d m : ℕ) (hm : Fintype.card (Position (d + 2)) ≤ 16 * m) (L : Sum ι α ≃ Position (d + 2)) (k : ℕ) (hk : k + m ≤ Fintype.card α) (e : Fin k → α) (he : Function.Injective e) : tv (fairMass (fun ω : History (d + 2) (400 * (d + 2)) => (splitPath L _ ω, splitTuple L _ ω e))) (fairMass (fun a : History (d + 2) (400 * (d + 2)) × Equiv.Perm α => (splitPath L _ a.1, splitTuple L _ a.1 (a.2 ∘ e)))) ≤ (k : ℝ) / 2 * Real.sqrt ((Fintype.card (Position (d + 2)) : ℝ) * ((1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ m)) := by have hh := fairMass_tv_le_of_test (fun ω : History (d + 2) (400 * (d + 2)) => (splitPath L _ ω, splitTuple L _ ω e)) (fun a : History (d + 2) (400 * (d + 2)) × Equiv.Perm α => (splitPath L _ a.1, splitTuple L _ a.1 (a.2 ∘ e))) ((k : ℝ) * Real.sqrt ((Fintype.card (Position (d + 2)) : ℝ) * ((1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ m))) (by intro f hf rw [mean_prod] exact splitTuple_test_400 d m hm L k hk e he (fun p z => f (p, z)) (fun p z => hf _)) convert hh using 1 ; first | rfl | ring end Thorp.Conditional namespace Revealed.Split open scoped Classical variable {ι α β : Type*} lemma perm_preserves_right (g : Equiv.Perm (Sum ι α)) (hg : ∀ i, g (.inl i) = .inl i) (a : α) : ∃ b, g (.inr a) = .inr b := by cases h : g (.inr a) with | inl i => have hh := g.injective (h.trans (hg i).symm) exact False.elim (Sum.inr_ne_inl hh) | inr b => exact ⟨b, rfl⟩ def rightPart (g : Equiv.Perm (Sum ι α)) (hg : ∀ i, g (.inl i) = .inl i) : Equiv.Perm α := Equiv.ofBijective (fun a => (perm_preserves_right g hg a).choose) (by constructor · intro a b h apply Sum.inr_injective apply g.injective rw [(perm_preserves_right g hg a).choose_spec, (perm_preserves_right g hg b).choose_spec] exact congrArg Sum.inr h · intro b obtain ⟨x, hx⟩ := g.surjective (.inr b) cases x with | inl i => rw [hg i] at hx; exact False.elim (Sum.inl_ne_inr hx) | inr a => refine ⟨a, ?_⟩ apply Sum.inr_injective exact (perm_preserves_right g hg a).choose_spec.symm.trans hx) lemma rightPart_spec (g : Equiv.Perm (Sum ι α)) (hg : ∀ i, g (.inl i) = .inl i) (a : α) : g (.inr a) = .inr (rightPart g hg a) := (perm_preserves_right g hg a).choose_spec def relative (L M : Sum ι α ≃ β) (h : ∀ i, L (.inl i) = M (.inl i)) : Equiv.Perm α := rightPart (L.trans M.symm) (fun i => by simp only [Equiv.trans_apply, h, Equiv.symm_apply_apply]) lemma relative_spec (L M : Sum ι α ≃ β) (h : ∀ i, L (.inl i) = M (.inl i)) (a : α) : M (.inr (relative L M h a)) = L (.inr a) := by have hh := rightPart_spec (L.trans M.symm) (fun i => by simp only [Equiv.trans_apply, h, Equiv.symm_apply_apply]) a exact (congrArg M hh).symm.trans (M.apply_symm_apply _) lemma relative_self (L : Sum ι α ≃ β) (h : ∀ i, L (.inl i) = L (.inl i)) : relative L L h = 1 := by ext a apply Sum.inr_injective apply L.injective exact relative_spec L L h a lemma relative_unique (L M : Sum ι α ≃ β) (h : ∀ i, L (.inl i) = M (.inl i)) (g : Equiv.Perm α) (hg : ∀ a, M (.inr (g a)) = L (.inr a)) : relative L M h = g := by ext a apply Sum.inr_injective apply M.injective exact (relative_spec L M h a).trans (hg a).symm lemma relative_factor (L M : Sum ι α ≃ β) (h : ∀ i, L (.inl i) = M (.inl i)) : (Equiv.sumCongr (Equiv.refl ι) (relative L M h)).trans M = L := by ext x cases x with | inl i => exact (h i).symm | inr a => exact relative_spec L M h a lemma relative_pre (L M : Sum ι α ≃ β) (h : ∀ i, L (.inl i) = M (.inl i)) (g : Equiv.Perm α) : relative ((Equiv.sumCongr (Equiv.refl ι) g).trans L) M h = relative L M h * g := by apply relative_unique intro a exact relative_spec L M h (g a) lemma relative_post (L M : Sum ι α ≃ β) (h : ∀ i, L (.inl i) = M (.inl i)) (W : Equiv.Perm β) : relative (L.trans W) (M.trans W) (fun i => congrArg W (h i)) = relative L M h := by apply relative_unique intro a exact congrArg W (relative_spec L M h a) abbrev Outside (ι α β : Type*) := {o : ι → β // ∃ L : Sum ι α ≃ β, ∀ i, L (.inl i) = o i} def outside (L : Sum ι α ≃ β) : Outside ι α β := ⟨fun i => L (.inl i), ⟨L, fun _ => rfl⟩⟩ def sectionFrame (o : Outside ι α β) : Sum ι α ≃ β := o.property.choose lemma sectionFrame_spec (o : Outside ι α β) (i : ι) : sectionFrame o (.inl i) = o.val i := o.property.choose_spec i @[simp] lemma outside_sectionFrame (o : Outside ι α β) : outside (sectionFrame o) = o := by apply Subtype.ext funext i exact sectionFrame_spec o i @[simp] lemma outside_pre (L : Sum ι α ≃ β) (g : Equiv.Perm α) : outside ((Equiv.sumCongr (Equiv.refl ι) g).trans L) = outside L := by rfl def assignment (L : Sum ι α ≃ β) : Equiv.Perm α := relative L (sectionFrame (outside L)) (fun i => (sectionFrame_spec (outside L) i).symm) lemma assignment_factor (L : Sum ι α ≃ β) : (Equiv.sumCongr (Equiv.refl ι) (assignment L)).trans (sectionFrame (outside L)) = L := relative_factor _ _ _ @[simp] lemma assignment_sectionFrame (o : Outside ι α β) : assignment (sectionFrame o) = 1 := by unfold assignment simp only [outside_sectionFrame] exact relative_self _ _ lemma assignment_pre (L : Sum ι α ≃ β) (g : Equiv.Perm α) : assignment ((Equiv.sumCongr (Equiv.refl ι) g).trans L) = assignment L * g := by unfold assignment exact relative_pre _ _ _ _ def nextOutside (o : Outside ι α β) (W : Equiv.Perm β) : Outside ι α β := outside ((sectionFrame o).trans W) def increment (o : Outside ι α β) (W : Equiv.Perm β) : Equiv.Perm α := assignment ((sectionFrame o).trans W) lemma outside_post (L : Sum ι α ≃ β) (W : Equiv.Perm β) : outside (L.trans W) = nextOutside (outside L) W := by apply Subtype.ext funext i exact congrArg W (sectionFrame_spec (outside L) i).symm lemma assignment_post (L : Sum ι α ≃ β) (W : Equiv.Perm β) : assignment (L.trans W) = increment (outside L) W * assignment L := by conv_lhs => rw [← assignment_factor L] rw [Equiv.trans_assoc, assignment_pre] rfl end Revealed.Split namespace Revealed.Split open scoped Classical variable {ι α β : Type*} def frameFor (fallback : Sum ι α ≃ β) (o : ι → β) : Sum ι α ≃ β := if h : ∃ L : Sum ι α ≃ β, ∀ i, L (.inl i) = o i then sectionFrame ⟨o, h⟩ else fallback @[simp] lemma frameFor_outside (fallback L : Sum ι α ≃ β) : frameFor fallback (outside L).val = sectionFrame (outside L) := by unfold frameFor rw [dite_eq_left (outside L).property] def indexRight [Nonempty α] (L : Sum ι α ≃ β) (x : β) : α := match L.symm x with | .inl _ => Classical.arbitrary α | .inr a => a @[simp] lemma indexRight_apply [Nonempty α] (L : Sum ι α ≃ β) (a : α) : indexRight L (L (.inr a)) = a := by simp [indexRight] lemma indexRight_assignment [Nonempty α] (L : Sum ι α ≃ β) (a : α) : indexRight (sectionFrame (outside L)) (L (.inr a)) = assignment L a := by rw [← relative_spec L (sectionFrame (outside L)) (fun i => (sectionFrame_spec (outside L) i).symm) a] exact indexRight_apply _ _ lemma indexRight_tuple [Nonempty α] {k : ℕ} (L : Sum ι α ≃ β) (W : Equiv.Perm β) (a : Fin k → α) : (fun j => indexRight (frameFor L (fun i => W (L (.inl i)))) (W (L (.inr (a j))))) = assignment (L.trans W) ∘ a := by funext j have hframe := frameFor_outside L (L.trans W) dsimp only [outside, Equiv.trans_apply] at hframe rw [hframe] exact indexRight_assignment (L.trans W) (a j) end Revealed.Split namespace Thorp.Conditional open scoped Classical open Revealed.Split lemma mean_perm_comp {α Z : Type*} [Fintype α] [DecidableEq α] (ρ : Equiv.Perm α) (e : Z → α) (f : (Z → α) → ℝ) : mean (fun σ : Equiv.Perm α => f (ρ ∘ (σ ∘ e))) = mean (fun σ : Equiv.Perm α => f (σ ∘ e)) := mean_equiv (Equiv.mulLeft ρ) (fun σ : Equiv.Perm α => f (σ ∘ e)) theorem assignmentTuple_test_400 {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] [Nonempty α] (d m : ℕ) (hm : Fintype.card (Position (d + 2)) ≤ 16 * m) (L : Sum ι α ≃ Position (d + 2)) (k : ℕ) (hk : k + m ≤ Fintype.card α) (e : Fin k → α) (he : Function.Injective e) (f : (Fin (400 * (d + 2) + 1) → ι → Position (d + 2)) → (Fin k → α) → ℝ) (hf : ∀ p z, |f p z| ≤ 1) : |mean (fun ω : History (d + 2) (400 * (d + 2)) => f (splitPath L _ ω) ((assignment (L.trans (run (d + 2) _ ω))) ∘ e)) - mean (fun ω : History (d + 2) (400 * (d + 2)) => mean (fun σ : Equiv.Perm α => f (splitPath L _ ω) (σ ∘ e)))| ≤ (k : ℝ) * Real.sqrt ((Fintype.card (Position (d + 2)) : ℝ) * ((1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ m)) := by let T := 400 * (d + 2) let F (p : Fin (T + 1) → ι → Position (d + 2)) (z : Fin k → Position (d + 2)) : ℝ := f p (fun j => indexRight (frameFor L (p (Fin.last T))) (z j)) have hh := splitTuple_test_400 d m hm L k hk e he F (fun p z => hf _ _) have hF (ω : History (d + 2) T) (a : Fin k → α) : F (splitPath L T ω) (splitTuple L T ω a) = f (splitPath L T ω) (assignment (L.trans (run (d + 2) T ω)) ∘ a) := by dsimp only [F, splitTuple] rw [splitPath_last, indexRight_tuple] dsimp only [T] at hF simp_rw [hF] at hh have hu (ω : History (d + 2) T) : mean (fun σ : Equiv.Perm α => f (splitPath L T ω) (assignment (L.trans (run (d + 2) T ω)) ∘ (σ ∘ e))) = mean (fun σ : Equiv.Perm α => f (splitPath L T ω) (σ ∘ e)) := mean_perm_comp (assignment (L.trans (run (d + 2) T ω))) e (f (splitPath L T ω)) dsimp only [T] at hu simp_rw [hu] at hh exact hh end Thorp.Conditional namespace Revealed.Disintegration open scoped Classical open Thorp variable {E G : Type*} [fintype_E : Fintype E] [Fintype G] [nonempty_G : Nonempty G] def marginal (μ : E × G → ℝ) (e : E) : ℝ := ∑ g, μ (e, g) def conditional (μ : E × G → ℝ) (e : E) (g : G) : ℝ := if marginal μ e = 0 then (Fintype.card G : ℝ)⁻¹ else μ (e, g) / marginal μ e lemma marginal_nonneg (μ : E × G → ℝ) (hμ : ∀ x, 0 ≤ μ x) (e : E) : 0 ≤ marginal μ e := by let retained_fintype_E := fintype_E let retained_nonempty_G := nonempty_G exact Finset.sum_nonneg (fun g _ => hμ (e, g)) lemma point_le_marginal (μ : E × G → ℝ) (hμ : ∀ x, 0 ≤ μ x) (e : E) (g : G) : μ (e, g) ≤ marginal μ e := by let retained_fintype_E := fintype_E let retained_nonempty_G := nonempty_G exact Finset.single_le_sum (fun x _ => hμ (e, x)) (Finset.mem_univ g) lemma conditional_nonneg (μ : E × G → ℝ) (hμ : ∀ x, 0 ≤ μ x) (e : E) (g : G) : 0 ≤ conditional μ e g := by unfold conditional split_ifs · positivity · exact div_nonneg (hμ _) (marginal_nonneg μ hμ e) lemma conditional_sum (μ : E × G → ℝ) (e : E) : ∑ g, conditional μ e g = 1 := by let retained_fintype_E := fintype_E by_cases h : marginal μ e = 0 · simp only [conditional, ite_eq_left h, Finset.sum_const, Finset.card_univ, nsmul_eq_mul] exact mul_inv_cancel₀ (by exact_mod_cast Fintype.card_ne_zero) · simp only [conditional, ite_eq_right h, ← Finset.sum_div] exact div_self h lemma marginal_mul_conditional (μ : E × G → ℝ) (hμ : ∀ x, 0 ≤ μ x) (e : E) (g : G) : marginal μ e * conditional μ e g = μ (e, g) := by unfold conditional split_ifs with h · have hz : μ (e, g) = 0 := le_antisymm ((point_le_marginal μ hμ e g).trans h.le) (hμ _) rw [h, hz, zero_mul] · exact mul_div_cancel₀ _ h lemma marginal_sum (μ : E × G → ℝ) : ∑ e, marginal μ e = ∑ x, μ x := by let retained_nonempty_G := nonempty_G simp only [marginal, Fintype.sum_prod_type] lemma marginal_fairMass {Ω : Type*} [Fintype Ω] (a : Ω → E) (b : Ω → G) : marginal (fairMass (fun ω => (a ω, b ω))) = fairMass a := by let retained_fintype_E := fintype_E let retained_nonempty_G := nonempty_G funext e unfold marginal fairMass rw [← Finset.sum_div, Finset.sum_comm] congr 1 apply Finset.sum_congr rfl intro ω _ simp [Prod.mk.injEq, ite_and] lemma fairMass_prod {Ω Ω' X Y : Type*} [Fintype Ω] [Fintype Ω'] (a : Ω → X) (b : Ω' → Y) (x : X) (y : Y) : fairMass (fun z : Ω × Ω' => (a z.1, b z.2)) (x, y) = fairMass a x * fairMass b y := by unfold fairMass simp only [Fintype.card_prod, Nat.cast_mul, Fintype.sum_prod_type, Prod.mk.injEq] rw [div_mul_div_comm, Finset.sum_mul] congr 1 apply Finset.sum_congr rfl intro ω _ rw [Finset.mul_sum] apply Finset.sum_congr rfl intro ω' _ split_ifs <;> simp_all lemma tv_joint_scaled {Y : Type*} [Fintype Y] (p : E → ℝ) (hp : ∀ e, 0 ≤ p e) (μ ν : E → Y → ℝ) : tv (fun a : E × Y => p a.1 * μ a.1 a.2) (fun a => p a.1 * ν a.1 a.2) = ∑ e, p e * tv (μ e) (ν e) := by simp only [tv, Fintype.sum_prod_type, ← mul_sub, abs_mul, abs_of_nonneg (hp _), ← Finset.mul_sum] rw [Finset.mul_sum] apply Finset.sum_congr rfl intro e _ ring lemma average_tv_eq (μ : E × G → ℝ) (hμ : ∀ x, 0 ≤ μ x) (ν : E → G → ℝ) : (∑ e, marginal μ e * tv (conditional μ e) (ν e)) = tv μ (fun a : E × G => marginal μ a.1 * ν a.1 a.2) := by rw [← tv_joint_scaled (marginal μ) (marginal_nonneg μ hμ)] congr 1 funext a exact marginal_mul_conditional μ hμ a.1 a.2 end Revealed.Disintegration namespace Revealed.Disintegration open scoped Classical open Thorp variable {E G Y : Type*} [fintype_E : Fintype E] [Fintype G] [fintype_Y : Fintype Y] [nonempty_G : Nonempty G] lemma push_preserve_first (μ : E × G → ℝ) (f : G → Y) (e : E) (y : Y) : Trim.push μ (fun a => (a.1, f a.2)) (e, y) = ∑ g, if f g = y then μ (e, g) else 0 := by let retained_fintype_Y := fintype_Y let retained_nonempty_G := nonempty_G simp only [Trim.push, Fintype.sum_prod_type, Prod.mk.injEq, ite_and] simp lemma marginal_mul_push (μ : E × G → ℝ) (hμ : ∀ x, 0 ≤ μ x) (f : G → Y) (e : E) (y : Y) : marginal μ e * Trim.push (conditional μ e) f y = ∑ g, if f g = y then μ (e, g) else 0 := by let retained_fintype_Y := fintype_Y rw [Trim.push, Finset.mul_sum] apply Finset.sum_congr rfl intro g _ split_ifs · exact marginal_mul_conditional μ hμ e g · exact mul_zero _ lemma projection_tv_eq (μ : E × G → ℝ) (hμ : ∀ x, 0 ≤ μ x) (f : G → Y) (u : G → ℝ) : (∑ e, marginal μ e * tv (Trim.push (conditional μ e) f) (Trim.push u f)) = tv (Trim.push μ (fun a => (a.1, f a.2))) (fun a : E × Y => marginal μ a.1 * Trim.push u f a.2) := by rw [← tv_joint_scaled (marginal μ) (marginal_nonneg μ hμ)] congr 1 funext a rw [push_preserve_first, marginal_mul_push μ hμ] lemma conditional_projection_le_of_test {Ω : Type*} [Fintype Ω] (a : Ω → E) (b : Ω → G) (r : G → Y) (C : ℝ) (h : ∀ f : E × Y → ℝ, (∀ z, |f z| ≤ 1) → |Conditional.mean (fun ω => f (a ω, r (b ω))) - Conditional.mean (fun ω => Conditional.mean (fun g : G => f (a ω, r g)))| ≤ C) : (∑ e, marginal (fairMass (fun ω => (a ω, b ω))) e * tv (Trim.push (conditional (fairMass (fun ω => (a ω, b ω))) e) r) (fairMass r)) ≤ C / 2 := by have hh := Conditional.fairMass_tv_le_of_test (fun ω : Ω => (a ω, r (b ω))) (fun z : Ω × G => (a z.1, r z.2)) C (by intro f hf rw [Conditional.mean_prod] exact h f hf) have hu : Trim.push (fun _ : G => (Fintype.card G : ℝ)⁻¹) r = fairMass r := by rw [Trim.uniform_eq_fairMass_id, Trim.push_fairMass] rfl have hp := projection_tv_eq (fairMass (fun ω => (a ω, b ω))) (fairMass_nonneg _) r (fun _ : G => (Fintype.card G : ℝ)⁻¹) rw [hu] at hp rw [hp, Trim.push_fairMass, marginal_fairMass] simp_rw [← fairMass_prod a r] exact hh end Revealed.Disintegration namespace Thorp.Conditional open scoped Classical open Revealed.Split Revealed.Disintegration def frameJoint {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] {d : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) : (Fin (t + 1) → ι → Position d) × Equiv.Perm α → ℝ := fairMass (fun ω : History d t => (splitPath L t ω, assignment (L.trans (run d t ω)))) def frameKernel {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] {d : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) : (Fin (t + 1) → ι → Position d) → Equiv.Perm α → ℝ := conditional (frameJoint L t) lemma frameJoint_nonneg {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] {d : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) (x) : 0 ≤ frameJoint L t x := fairMass_nonneg _ _ lemma frameKernel_nonneg {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] {d : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) (p g) : 0 ≤ frameKernel L t p g := conditional_nonneg _ (frameJoint_nonneg L t) p g lemma frameKernel_sum {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] {d : ℕ} (L : Sum ι α ≃ Position d) (t : ℕ) (p) : ∑ g, frameKernel L t p g = 1 := conditional_sum _ p lemma frameKernel_tuple_bound {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] [Nonempty α] {d t k : ℕ} (L : Sum ι α ≃ Position d) (e : Fin k → α) (C : ℝ) (h : ∀ (f : (Fin (t + 1) → ι → Position d) → (Fin k → α) → ℝ), (∀ p z, |f p z| ≤ 1) → |mean (fun ω : History d t => f (splitPath L t ω) (assignment (L.trans (run d t ω)) ∘ e)) - mean (fun ω : History d t => mean (fun g : Equiv.Perm α => f (splitPath L t ω) (g ∘ e)))| ≤ C) : (∑ p, marginal (frameJoint L t) p * tv (Trim.push (frameKernel L t p) (fun g : Equiv.Perm α => g ∘ e)) (fairMass (fun g : Equiv.Perm α => g ∘ e))) ≤ C / 2 := by exact conditional_projection_le_of_test (fun ω : History d t => splitPath L t ω) (fun ω : History d t => assignment (L.trans (run d t ω))) (fun g : Equiv.Perm α => g ∘ e) C (fun f hf => h (fun p z => f (p,z)) (fun p z => hf _)) theorem frameKernel_marginal_400 {ι α : Type*} [Fintype ι] [Fintype α] [DecidableEq α] [Nonempty α] (d m : ℕ) (hm : Fintype.card (Position (d + 2)) ≤ 16 * m) (L : Sum ι α ≃ Position (d + 2)) (k : ℕ) (hk : k + m ≤ Fintype.card α) (e : Fin k → α) (he : Function.Injective e) : (∑ p, marginal (frameJoint L (400 * (d + 2))) p * tv (Trim.push (frameKernel L (400 * (d + 2)) p) (fun g : Equiv.Perm α => g ∘ e)) (fairMass (fun g : Equiv.Perm α => g ∘ e))) ≤ (k : ℝ) / 2 * Real.sqrt ((Fintype.card (Position (d + 2)) : ℝ) * ((1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ m)) := by have hh := frameKernel_tuple_bound L e ((k : ℝ) * Real.sqrt ((Fintype.card (Position (d + 2)) : ℝ) * ((1 / 2 : ℝ) ^ (8 * (d + 2)) + 64 * (9 / 10 : ℝ) ^ m))) (assignmentTuple_test_400 d m hm L k hk e he) exact hh.trans_eq (by ring) end Thorp.Conditional end end OAI
import OAI.Probability.ThorpShuffle.Main
namespace OAI
noncomputable section
open scoped BigOperators
open Filter
namespace Revealed
open Thorp
open scoped Classical
def outside (d : ℕ) : Position d → Position (d + 1) := fun x => Fin.cons true x
def freeLabel (d : ℕ) : Position d → Position (d + 1) := fun x => Fin.cons false x
lemma freeLabel_injective (d : ℕ) : Function.Injective (freeLabel d) := by
intro x y h
exact congrArg Fin.tail h
def imageRank {α β : Type*} [Fintype α] [LinearOrder β]
(f : α → β) (hf : Function.Injective f) : α ≃ Fin (Fintype.card α) := by
classical
let e := Equiv.ofInjective f hf
exact e.trans (Fintype.orderIsoFinOfCardEq (Set.range f)
(Fintype.card_congr e).symm).toEquiv.symm
def freeRank (d : ℕ) (g : State (d + 1)) : Position d ≃ Fin (2 ^ d) :=
(imageRank (fun x => toLex (g (freeLabel d x)))
(by intro x y h; exact congrArg Fin.tail (g.injective h))).trans
(finCongr (by simp [Position]))
def layoutPath (d : ℕ) (g₀ : State d) :
(t : ℕ) → History d t → Fin (t + 1) → State d
| 0, _ => fun _ => g₀
| t + 1, ω => Fin.snoc (layoutPath d g₀ t (Fin.init ω)) (run d (t + 1) ω * g₀)
abbrev Environment (d t : ℕ) := Fin (t + 1) → Position d → Position (d + 1)
def outsidePaths (d t : ℕ) (g₀ : State (d + 1))
(ω : History (d + 1) t) : Environment d t :=
fun s x => layoutPath (d + 1) g₀ t ω s (outside d x)
def slotPermutation (d t : ℕ) (g₀ : State (d + 1))
(ω : History (d + 1) t) : Equiv.Perm (Fin (2 ^ d)) :=
(freeRank d g₀).symm.trans (freeRank d (run (d + 1) t ω * g₀))
def environmentMass (d t : ℕ) (g₀ : State (d + 1)) : Environment d t → ℝ :=
fairMass (outsidePaths d t g₀)
def conditionalLaw (d t : ℕ) (g₀ : State (d + 1))
(e : Environment d t) (g : Equiv.Perm (Fin (2 ^ d))) : ℝ :=
fairMass (fun ω : History (d + 1) t =>
(outsidePaths d t g₀ ω, slotPermutation d t g₀ ω)) (e, g) /
environmentMass d t g₀ e
def expectedTV (d t : ℕ) (g₀ : State (d + 1)) : ℝ :=
∑ e, environmentMass d t g₀ e *
tv (conditionalLaw d t g₀ e)
(fun _ => 1 / (Nat.factorial (2 ^ d) : ℝ))
def worstConditionalTV (d t : ℕ) : ℝ :=
Finset.univ.sup' Finset.univ_nonempty (expectedTV d t)
def twoHalfL : ℕ := 2 ^ 23
def twoHalfP : ℝ := 1 - 1 / (((2 : ℕ) : ℝ) * (twoHalfL : ℝ))
def twoHalfC : ℝ :=
-(1 / ((8 : ℕ) : ℝ)) *
Real.logb ((2 : ℕ) : ℝ) ((3 + twoHalfP) / ((4 : ℕ) : ℝ))
def twoHalfB : ℕ := ⌈((10 : ℕ) : ℝ) / twoHalfC⌉₊
end Revealed
namespace Thorp.Conditional
open scoped Classical
def exposedPath {ι : Type*} (d : ℕ) (e : ι → Position d) :
(t : ℕ) → History d t → Fin (t + 1) → ι → Position d
| 0, _ => fun _ => e
| t + 1, ω => Fin.snoc (exposedPath d e t (Fin.init ω)) (run d (t + 1) ω ∘ e)
@[simp] lemma exposedPath_last {ι : Type*} (d t : ℕ) (e : ι → Position d)
(ω : History d t) : exposedPath d e t ω (Fin.last t) = run d t ω ∘ e := by
cases t with
| zero => simp [exposedPath, run_zero]
| succ t => exact Fin.snoc_last _ _
@[simp] lemma exposedPath_snoc {ι : Type*} (d t : ℕ) (e : ι → Position d)
(ω : History d t) (c : Coins d) :
exposedPath d e (t + 1) (Fin.snoc ω c) =
Fin.snoc (exposedPath d e t ω) ((step d c * run d t ω) ∘ e) := by
simp only [exposedPath, Fin.init_snoc, run_snoc]
theorem flow_path_joint_identity {ι : Type*} (d : ℕ) (v : RawState (d + 1))
(e : ι → Position (d + 1)) (he : ∀ i, v.free (e i) = false)
(t : ℕ) (f : (Fin (t + 1) → ι → Position (d + 1)) → Position (d + 1) → ℝ) :
mean (fun ω : History (d + 1) t =>