| import OAI.Dynamics.ConditionalShuffle.ResetReverse |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Classical |
| open Filter Topology |
| namespace Thorp.Conditional.Reset |
|
|
| abbrev Injection (D b : ℕ) := Fin b ↪ Position D |
|
|
| def act {α ι : Type*} (g : Equiv.Perm α) (x : ι ↪ α) : ι ↪ α := x.trans g.toEmbedding |
|
|
| @[simp] lemma act_apply {α ι : Type*} (g : Equiv.Perm α) (x : ι ↪ α) (i : ι) : |
| act g x i = g (x i) := rfl |
|
|
| @[simp] lemma act_mul {α ι : Type*} (g h : Equiv.Perm α) (x : ι ↪ α) : |
| act (g*h) x = act g (act h x) := rfl |
|
|
| @[simp] lemma act_one {α ι : Type*} (x : ι ↪ α) : act (1 : Equiv.Perm α) x = x := rfl |
|
|
| lemma act_eq_iff {α ι : Type*} (g : Equiv.Perm α) (x y : ι ↪ α) : |
| act g x = y ↔ x = act g⁻¹ y := by |
| constructor |
| · intro h; rw [← h, ← act_mul, inv_mul_cancel, act_one] |
| · intro h; rw [h, ← act_mul, mul_inv_cancel, act_one] |
|
|
| def actEquiv {α ι : Type*} (g : Equiv.Perm α) : (ι ↪ α) ≃ (ι ↪ α) where |
| toFun := act g |
| invFun := act g⁻¹ |
| left_inv x := by rw [← act_mul, inv_mul_cancel, act_one] |
| right_inv x := by rw [← act_mul, mul_inv_cancel, act_one] |
|
|
| lemma uniform_injection {α ι : Type*} [Fintype α] [Fintype ι] [DecidableEq α] |
| (e : ι ↪ α) : fairMass (fun g : Equiv.Perm α => act g e) = |
| fun _ => (Fintype.card (ι ↪ α) : ℝ)⁻¹ := by |
| funext y |
| rw [fairMass_eq_mean, show (fun g : Equiv.Perm α => if act g e = y then (1:ℝ) else 0) = |
| (fun g => (fun z : ι ↪ α => if z = y then (1:ℝ) else 0) (e.trans g.toEmbedding)) from rfl, |
| mean_perm_embedding e (fun z : ι ↪ α => if z = y then (1:ℝ) else 0)] |
| simp [mean] |
|
|
| def kernel (D b t : ℕ) (x y : Injection D b) : ℝ := |
| fairMass (fun ω : History D t => act (run D t ω) x) y |
|
|
| lemma kernel_nonneg (D b t : ℕ) (x y : Injection D b) : 0 ≤ kernel D b t x y := |
| fairMass_nonneg _ _ |
|
|
| lemma kernel_row_sum (D b t : ℕ) (x : Injection D b) : ∑ y, kernel D b t x y = 1 := |
| fairMass_sum _ |
|
|
| lemma kernel_column_sum (D b t : ℕ) (y : Injection D b) : ∑ x, kernel D b t x y = 1 := by |
| unfold kernel |
| simp only [fairMass_eq_mean] |
| rw [← mean_sum] |
| have he (ω : History D t) : (∑ x : Injection D b, if act (run D t ω) x = y then (1:ℝ) else 0) = 1 := by |
| simp_rw [act_eq_iff]; simp |
| simp only [he, mean_const] |
|
|
| def toInjection {α ι : Type*} (e : ι ↪ α) (f : ι → α) : ι ↪ α := |
| if h : Function.Injective f then ⟨f,h⟩ else e |
|
|
| @[simp] lemma toInjection_coe {α ι : Type*} (e x : ι ↪ α) : toInjection e x = x := by |
| simp only [toInjection, dite_eq_left x.injective]; rfl |
|
|
| lemma injection_tv_le {α ι Ω Ω' : Type*} [Fintype α] [Fintype ι] [Fintype Ω] [Fintype Ω'] [DecidableEq ι] |
| (e : ι ↪ α) (a : Ω → ι ↪ α) (b : Ω' → ι ↪ α) : |
| tv (fairMass a) (fairMass b) ≤ |
| tv (fairMass (fun ω => (a ω : ι → α))) (fairMass (fun ω => (b ω : ι → α))) := by |
| have hh := Trim.tv_push_le (fairMass (fun ω => (a ω : ι → α))) |
| (fairMass (fun ω => (b ω : ι → α))) (toInjection e) |
| rw [Trim.push_fairMass, Trim.push_fairMass] at hh |
| simpa only [Function.comp_def, toInjection_coe] using hh |
| |
| lemma kernel_row_bound (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) : |
| ∀ᶠ d : ℕ in atTop, ∀ (b : ℕ), (b : ℝ) ≤ (1-ρ)*(2^(d+2) : ℝ) → |
| ∀ x : Injection (d+2) b, |
| tv (kernel (d+2) b (2*resetS ρ*(d+2)) x) |
| (fun _ => (Fintype.card (Injection (d+2) b) : ℝ)⁻¹) ≤ (1/2 : ℝ)^(8*(d+2)) := by |
| filter_upwards [reset_partial_mixing ρ hρ hρ₁] with d hd |
| intro b hb x |
| rw [← uniform_injection x] |
| exact (injection_tv_le x (fun ω : History (d+2) (2*resetS ρ*(d+2)) => |
| act (run (d+2) (2*resetS ρ*(d+2)) ω) x) (fun g : State (d+2) => act g x)).trans |
| (hd b x x.injective hb) |
| |
| lemma reflection_column (d b t : ℕ) (x y : Injection (d+1) b) : |
| kernel (d+1) b t x y = |
| kernel (d+1) b t (act (reversePosition (d+1)) y) (act (reversePosition (d+1)) x) := by |
| unfold kernel |
| rw [fairMass_eq_mean, fairMass_eq_mean] |
| rw [← mean_equiv (reverseHistory d t)] |
| apply mean_congr; intro ω |
| dsimp only [Function.comp_def] |
| rw [reverse_run] |
| have hr : reversePosition (d+1) * reversePosition (d+1) = 1 := by |
| apply Equiv.ext; exact reversePosition_involutive (d+1) |
| have iff : act (reversePosition (d+1) * (run (d+1) t ω)⁻¹ * reversePosition (d+1)) x = y ↔ |
| act (run (d+1) t ω) (act (reversePosition (d+1)) y) = act (reversePosition (d+1)) x := by |
| rw [act_eq_iff, mul_inv_rev, mul_inv_rev] |
| have hi : (reversePosition (d+1))⁻¹ = reversePosition (d+1) := by |
| apply inv_eq_of_mul_eq_one_left; exact hr |
| rw [hi, act_mul, act_mul, inv_inv] |
| have hre (z : Injection (d+1) b) : act (reversePosition (d+1)) (act (reversePosition (d+1)) z) = z := by |
| rw [← act_mul, hr, act_one] |
| constructor |
| · intro h; rw [h, hre] |
| · intro h; rw [h, hre] |
| simp only [iff] |
| |
| lemma kernel_column_bound (ρ : ℝ) (hρ : 0 < ρ) (hρ₁ : ρ ≤ 1) : |
| ∀ᶠ d : ℕ in atTop, ∀ (b : ℕ), (b : ℝ) ≤ (1-ρ)*(2^(d+2) : ℝ) → |
| ∀ y : Injection (d+2) b, |
| tv (fun x => kernel (d+2) b (2*resetS ρ*(d+2)) x y) |
| (fun _ => (Fintype.card (Injection (d+2) b) : ℝ)⁻¹) ≤ (1/2 : ℝ)^(8*(d+2)) := by |
| filter_upwards [kernel_row_bound ρ hρ hρ₁] with d hd |
| intro b hb y |
| have hh := hd b hb (act (reversePosition (d+2)) y) |
| have hsum : |
| (∑ x, |kernel (d+2) b (2*resetS ρ*(d+2)) x y - (Fintype.card (Injection (d+2) b) : ℝ)⁻¹|) = |
| ∑ x, |kernel (d+2) b (2*resetS ρ*(d+2)) (act (reversePosition (d+2)) y) x - |
| (Fintype.card (Injection (d+2) b) : ℝ)⁻¹| := by |
| calc |
| _ = ∑ x, |kernel (d+2) b (2*resetS ρ*(d+2)) (act (reversePosition (d+2)) y) |
| (act (reversePosition (d+2)) x) - (Fintype.card (Injection (d+2) b) : ℝ)⁻¹| := by |
| apply Finset.sum_congr rfl; intro x _ |
| rw [reflection_column (d+1) b (2*resetS ρ*(d+2)) x y] |
| _ = _ := (actEquiv (ι := Fin b) (reversePosition (d+2))).sum_comp |
| (fun x => |kernel (d+2) b (2*resetS ρ*(d+2)) (act (reversePosition (d+2)) y) x - |
| (Fintype.card (Injection (d+2) b) : ℝ)⁻¹|) |
| unfold tv at *; rwa [hsum] |
| |
| end Thorp.Conditional.Reset |
| |
| end |
| |
| end OAI |
| |
