Download data/lean/OAI/Dynamics/ConditionalShuffle/Disintegration.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 58.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/ConditionalShuffle/Disintegration.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/ConditionalShuffle/Disintegration.lean
-
curl -L -o Disintegration.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/ConditionalShuffle/Disintegration.lean
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 =>